From 6fb252ee777258c03f9b3409f20b2089f25eeca9 Mon Sep 17 00:00:00 2001 From: egibs <20933572+egibs@users.noreply.github.com> Date: Mon, 22 Jul 2024 09:28:43 -0500 Subject: [PATCH 1/2] Address false positives for SQLPad and Lerna Signed-off-by: egibs <20933572+egibs@users.noreply.github.com> --- pkg/compile/compile.go | 1 + rules/evasion/base64-python.yara | 43 ++++++++++++++++++-------------- 2 files changed, 25 insertions(+), 19 deletions(-) diff --git a/pkg/compile/compile.go b/pkg/compile/compile.go index a946201f4..02eb3a950 100644 --- a/pkg/compile/compile.go +++ b/pkg/compile/compile.go @@ -25,6 +25,7 @@ var badRules = map[string]bool{ "MALPEDIA_Win_Unidentified_107_Auto": true, "SIGNATURE_BASE_SUSP_PS1_JAB_Pattern_Jun22_1": true, "ELCEEF_HTML_Smuggling_A": true, + "DELIVRTO_SUSP_HTML_WASM_Smuggling": true, // ThreatHunting Keywords (some duplicates) "Adobe_XMP_Identifier": true, "Antivirus_Signature_signature_keyword": true, diff --git a/rules/evasion/base64-python.yara b/rules/evasion/base64-python.yara index 8ca8085bf..ec6135885 100644 --- a/rules/evasion/base64-python.yara +++ b/rules/evasion/base64-python.yara @@ -6,24 +6,29 @@ rule base64_python_functions : critical { hash_2023_0xShell_wesobase = "17a1219bf38d953ed22bbddd5aaf1811b9380ad0535089e6721d755a00bddbd0" hash_2024_static_demonizedshell_static = "b4e65c01ab90442cb5deda26660a3f81bd400c205e12605536483f979023aa15" strings: - $exec = "exec(" base64 - $eval = "eval(" base64 - $import_os = "import os" base64 - $import = "__import__" base64 - $importlib = "importlib" base64 - $import_module = "import_module" base64 - $urllib = "urllib.request" base64 - $requests_get = "requests.get" base64 - $urlopen = "urlopen" base64 - $read = "read()" base64 - $decode = "decode()" base64 - $b64decode = "base64.b64decode" base64 - $exc = "except Exception as" base64 - $os_system = "os.system" base64 - $os_popen = "os.popen" base64 - $thread = "threading.Thread" base64 - $os_environ = "os.environ" base64 - $with_open = "with open(" base64 + $f_exec = "exec(" base64 + $f_eval = "eval(" base64 + $f_import_os = "import os" base64 + $f_import = "__import__" base64 + $f_importlib = "importlib" base64 + $f_import_module = "import_module" base64 + $f_urllib = "urllib.request" base64 + $f_requests_get = "requests.get" base64 + $f_urlopen = "urlopen" base64 + $f_read = "read()" base64 + $f_decode = "decode()" base64 + $f_b64decode = "base64.b64decode" base64 + $f_exc = "except Exception as" base64 + $f_os_system = "os.system" base64 + $f_os_popen = "os.popen" base64 + $f_thread = "threading.Thread" base64 + $f_os_environ = "os.environ" base64 + $f_with_open = "with open(" base64 + $not_js = " ?? " base64 + $not_js2 = " === " base64 + $not_js3 = "const" base64 + $not_js4 = "this." base64 + $not_js5 = "throw" base64 condition: - 2 of them + 2 of ($f*) and none of ($not*) } From 635c47c00cc7b996714e17e73241bf9e0ea63f88 Mon Sep 17 00:00:00 2001 From: egibs <20933572+egibs@users.noreply.github.com> Date: Mon, 22 Jul 2024 09:55:37 -0500 Subject: [PATCH 2/2] Add samples for Lerna and SQLPad Signed-off-by: egibs <20933572+egibs@users.noreply.github.com> --- samples/Javascript/clean/connection.js | 2700 ++++ samples/Javascript/clean/connection.js.simple | 8 + samples/Javascript/clean/napi_rs_runtime.js | 11538 ++++++++++++++++ .../clean/napi_rs_runtime.js.simple | 21 + 4 files changed, 14267 insertions(+) create mode 100644 samples/Javascript/clean/connection.js create mode 100644 samples/Javascript/clean/connection.js.simple create mode 100644 samples/Javascript/clean/napi_rs_runtime.js create mode 100644 samples/Javascript/clean/napi_rs_runtime.js.simple diff --git a/samples/Javascript/clean/connection.js b/samples/Javascript/clean/connection.js new file mode 100644 index 000000000..460c195cf --- /dev/null +++ b/samples/Javascript/clean/connection.js @@ -0,0 +1,2700 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _crypto = _interopRequireDefault(require("crypto")); +var _os = _interopRequireDefault(require("os")); +var tls = _interopRequireWildcard(require("tls")); +var net = _interopRequireWildcard(require("net")); +var _dns = _interopRequireDefault(require("dns")); +var _constants = _interopRequireDefault(require("constants")); +var _stream = require("stream"); +var _identity = require("@azure/identity"); +var _bulkLoad = _interopRequireDefault(require("./bulk-load")); +var _debug = _interopRequireDefault(require("./debug")); +var _events = require("events"); +var _instanceLookup = require("./instance-lookup"); +var _transientErrorLookup = require("./transient-error-lookup"); +var _packet = require("./packet"); +var _preloginPayload = _interopRequireDefault(require("./prelogin-payload")); +var _login7Payload = _interopRequireDefault(require("./login7-payload")); +var _ntlmPayload = _interopRequireDefault(require("./ntlm-payload")); +var _request = _interopRequireDefault(require("./request")); +var _rpcrequestPayload = _interopRequireDefault(require("./rpcrequest-payload")); +var _sqlbatchPayload = _interopRequireDefault(require("./sqlbatch-payload")); +var _messageIo = _interopRequireDefault(require("./message-io")); +var _tokenStreamParser = require("./token/token-stream-parser"); +var _transaction = require("./transaction"); +var _errors = require("./errors"); +var _connector = require("./connector"); +var _library = require("./library"); +var _tdsVersions = require("./tds-versions"); +var _message = _interopRequireDefault(require("./message")); +var _ntlm = require("./ntlm"); +var _nodeAbortController = require("node-abort-controller"); +var _dataType = require("./data-type"); +var _bulkLoadPayload = require("./bulk-load-payload"); +var _specialStoredProcedure = _interopRequireDefault(require("./special-stored-procedure")); +var _esAggregateError = _interopRequireDefault(require("es-aggregate-error")); +var _package = require("../package.json"); +var _url = require("url"); +var _handler = require("./token/handler"); +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +// eslint-disable-next-line @typescript-eslint/no-unused-vars + +/** + * @private + */ +const KEEP_ALIVE_INITIAL_DELAY = 30 * 1000; +/** + * @private + */ +const DEFAULT_CONNECT_TIMEOUT = 15 * 1000; +/** + * @private + */ +const DEFAULT_CLIENT_REQUEST_TIMEOUT = 15 * 1000; +/** + * @private + */ +const DEFAULT_CANCEL_TIMEOUT = 5 * 1000; +/** + * @private + */ +const DEFAULT_CONNECT_RETRY_INTERVAL = 500; +/** + * @private + */ +const DEFAULT_PACKET_SIZE = 4 * 1024; +/** + * @private + */ +const DEFAULT_TEXTSIZE = 2147483647; +/** + * @private + */ +const DEFAULT_DATEFIRST = 7; +/** + * @private + */ +const DEFAULT_PORT = 1433; +/** + * @private + */ +const DEFAULT_TDS_VERSION = '7_4'; +/** + * @private + */ +const DEFAULT_LANGUAGE = 'us_english'; +/** + * @private + */ +const DEFAULT_DATEFORMAT = 'mdy'; + +/** + * @private + */ + +/** + * @private + */ +const CLEANUP_TYPE = { + NORMAL: 0, + REDIRECT: 1, + RETRY: 2 +}; +/** + * A [[Connection]] instance represents a single connection to a database server. + * + * ```js + * var Connection = require('tedious').Connection; + * var config = { + * "authentication": { + * ..., + * "options": {...} + * }, + * "options": {...} + * }; + * var connection = new Connection(config); + * ``` + * + * Only one request at a time may be executed on a connection. Once a [[Request]] + * has been initiated (with [[Connection.callProcedure]], [[Connection.execSql]], + * or [[Connection.execSqlBatch]]), another should not be initiated until the + * [[Request]]'s completion callback is called. + */ +class Connection extends _events.EventEmitter { + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + _cancelAfterRequestSent; + + /** + * @private + */ + + /** + * Note: be aware of the different options field: + * 1. config.authentication.options + * 2. config.options + * + * ```js + * const { Connection } = require('tedious'); + * + * const config = { + * "authentication": { + * ..., + * "options": {...} + * }, + * "options": {...} + * }; + * + * const connection = new Connection(config); + * ``` + * + * @param config + */ + constructor(config) { + super(); + if (typeof config !== 'object' || config === null) { + throw new TypeError('The "config" argument is required and must be of type Object.'); + } + if (typeof config.server !== 'string') { + throw new TypeError('The "config.server" property is required and must be of type string.'); + } + this.fedAuthRequired = false; + let authentication; + if (config.authentication !== undefined) { + if (typeof config.authentication !== 'object' || config.authentication === null) { + throw new TypeError('The "config.authentication" property must be of type Object.'); + } + const type = config.authentication.type; + const options = config.authentication.options === undefined ? {} : config.authentication.options; + if (typeof type !== 'string') { + throw new TypeError('The "config.authentication.type" property must be of type string.'); + } + if (type !== 'default' && type !== 'ntlm' && type !== 'azure-active-directory-password' && type !== 'azure-active-directory-access-token' && type !== 'azure-active-directory-msi-vm' && type !== 'azure-active-directory-msi-app-service' && type !== 'azure-active-directory-service-principal-secret' && type !== 'azure-active-directory-default') { + throw new TypeError('The "type" property must one of "default", "ntlm", "azure-active-directory-password", "azure-active-directory-access-token", "azure-active-directory-default", "azure-active-directory-msi-vm" or "azure-active-directory-msi-app-service" or "azure-active-directory-service-principal-secret".'); + } + if (typeof options !== 'object' || options === null) { + throw new TypeError('The "config.authentication.options" property must be of type object.'); + } + if (type === 'ntlm') { + if (typeof options.domain !== 'string') { + throw new TypeError('The "config.authentication.options.domain" property must be of type string.'); + } + if (options.userName !== undefined && typeof options.userName !== 'string') { + throw new TypeError('The "config.authentication.options.userName" property must be of type string.'); + } + if (options.password !== undefined && typeof options.password !== 'string') { + throw new TypeError('The "config.authentication.options.password" property must be of type string.'); + } + authentication = { + type: 'ntlm', + options: { + userName: options.userName, + password: options.password, + domain: options.domain && options.domain.toUpperCase() + } + }; + } else if (type === 'azure-active-directory-password') { + if (typeof options.clientId !== 'string') { + throw new TypeError('The "config.authentication.options.clientId" property must be of type string.'); + } + if (options.userName !== undefined && typeof options.userName !== 'string') { + throw new TypeError('The "config.authentication.options.userName" property must be of type string.'); + } + if (options.password !== undefined && typeof options.password !== 'string') { + throw new TypeError('The "config.authentication.options.password" property must be of type string.'); + } + if (options.tenantId !== undefined && typeof options.tenantId !== 'string') { + throw new TypeError('The "config.authentication.options.tenantId" property must be of type string.'); + } + authentication = { + type: 'azure-active-directory-password', + options: { + userName: options.userName, + password: options.password, + tenantId: options.tenantId, + clientId: options.clientId + } + }; + } else if (type === 'azure-active-directory-access-token') { + if (typeof options.token !== 'string') { + throw new TypeError('The "config.authentication.options.token" property must be of type string.'); + } + authentication = { + type: 'azure-active-directory-access-token', + options: { + token: options.token + } + }; + } else if (type === 'azure-active-directory-msi-vm') { + if (options.clientId !== undefined && typeof options.clientId !== 'string') { + throw new TypeError('The "config.authentication.options.clientId" property must be of type string.'); + } + authentication = { + type: 'azure-active-directory-msi-vm', + options: { + clientId: options.clientId + } + }; + } else if (type === 'azure-active-directory-default') { + if (options.clientId !== undefined && typeof options.clientId !== 'string') { + throw new TypeError('The "config.authentication.options.clientId" property must be of type string.'); + } + authentication = { + type: 'azure-active-directory-default', + options: { + clientId: options.clientId + } + }; + } else if (type === 'azure-active-directory-msi-app-service') { + if (options.clientId !== undefined && typeof options.clientId !== 'string') { + throw new TypeError('The "config.authentication.options.clientId" property must be of type string.'); + } + authentication = { + type: 'azure-active-directory-msi-app-service', + options: { + clientId: options.clientId + } + }; + } else if (type === 'azure-active-directory-service-principal-secret') { + if (typeof options.clientId !== 'string') { + throw new TypeError('The "config.authentication.options.clientId" property must be of type string.'); + } + if (typeof options.clientSecret !== 'string') { + throw new TypeError('The "config.authentication.options.clientSecret" property must be of type string.'); + } + if (typeof options.tenantId !== 'string') { + throw new TypeError('The "config.authentication.options.tenantId" property must be of type string.'); + } + authentication = { + type: 'azure-active-directory-service-principal-secret', + options: { + clientId: options.clientId, + clientSecret: options.clientSecret, + tenantId: options.tenantId + } + }; + } else { + if (options.userName !== undefined && typeof options.userName !== 'string') { + throw new TypeError('The "config.authentication.options.userName" property must be of type string.'); + } + if (options.password !== undefined && typeof options.password !== 'string') { + throw new TypeError('The "config.authentication.options.password" property must be of type string.'); + } + authentication = { + type: 'default', + options: { + userName: options.userName, + password: options.password + } + }; + } + } else { + authentication = { + type: 'default', + options: { + userName: undefined, + password: undefined + } + }; + } + this.config = { + server: config.server, + authentication: authentication, + options: { + abortTransactionOnError: false, + appName: undefined, + camelCaseColumns: false, + cancelTimeout: DEFAULT_CANCEL_TIMEOUT, + columnEncryptionKeyCacheTTL: 2 * 60 * 60 * 1000, + // Units: milliseconds + columnEncryptionSetting: false, + columnNameReplacer: undefined, + connectionRetryInterval: DEFAULT_CONNECT_RETRY_INTERVAL, + connectTimeout: DEFAULT_CONNECT_TIMEOUT, + connector: undefined, + connectionIsolationLevel: _transaction.ISOLATION_LEVEL.READ_COMMITTED, + cryptoCredentialsDetails: {}, + database: undefined, + datefirst: DEFAULT_DATEFIRST, + dateFormat: DEFAULT_DATEFORMAT, + debug: { + data: false, + packet: false, + payload: false, + token: false + }, + enableAnsiNull: true, + enableAnsiNullDefault: true, + enableAnsiPadding: true, + enableAnsiWarnings: true, + enableArithAbort: true, + enableConcatNullYieldsNull: true, + enableCursorCloseOnCommit: null, + enableImplicitTransactions: false, + enableNumericRoundabort: false, + enableQuotedIdentifier: true, + encrypt: true, + fallbackToDefaultDb: false, + encryptionKeyStoreProviders: undefined, + instanceName: undefined, + isolationLevel: _transaction.ISOLATION_LEVEL.READ_COMMITTED, + language: DEFAULT_LANGUAGE, + localAddress: undefined, + maxRetriesOnTransientErrors: 3, + multiSubnetFailover: false, + packetSize: DEFAULT_PACKET_SIZE, + port: DEFAULT_PORT, + readOnlyIntent: false, + requestTimeout: DEFAULT_CLIENT_REQUEST_TIMEOUT, + rowCollectionOnDone: false, + rowCollectionOnRequestCompletion: false, + serverName: undefined, + serverSupportsColumnEncryption: false, + tdsVersion: DEFAULT_TDS_VERSION, + textsize: DEFAULT_TEXTSIZE, + trustedServerNameAE: undefined, + trustServerCertificate: false, + useColumnNames: false, + useUTC: true, + workstationId: undefined, + lowerCaseGuids: false + } + }; + if (config.options) { + if (config.options.port && config.options.instanceName) { + throw new Error('Port and instanceName are mutually exclusive, but ' + config.options.port + ' and ' + config.options.instanceName + ' provided'); + } + if (config.options.abortTransactionOnError !== undefined) { + if (typeof config.options.abortTransactionOnError !== 'boolean' && config.options.abortTransactionOnError !== null) { + throw new TypeError('The "config.options.abortTransactionOnError" property must be of type string or null.'); + } + this.config.options.abortTransactionOnError = config.options.abortTransactionOnError; + } + if (config.options.appName !== undefined) { + if (typeof config.options.appName !== 'string') { + throw new TypeError('The "config.options.appName" property must be of type string.'); + } + this.config.options.appName = config.options.appName; + } + if (config.options.camelCaseColumns !== undefined) { + if (typeof config.options.camelCaseColumns !== 'boolean') { + throw new TypeError('The "config.options.camelCaseColumns" property must be of type boolean.'); + } + this.config.options.camelCaseColumns = config.options.camelCaseColumns; + } + if (config.options.cancelTimeout !== undefined) { + if (typeof config.options.cancelTimeout !== 'number') { + throw new TypeError('The "config.options.cancelTimeout" property must be of type number.'); + } + this.config.options.cancelTimeout = config.options.cancelTimeout; + } + if (config.options.columnNameReplacer) { + if (typeof config.options.columnNameReplacer !== 'function') { + throw new TypeError('The "config.options.cancelTimeout" property must be of type function.'); + } + this.config.options.columnNameReplacer = config.options.columnNameReplacer; + } + if (config.options.connectionIsolationLevel !== undefined) { + (0, _transaction.assertValidIsolationLevel)(config.options.connectionIsolationLevel, 'config.options.connectionIsolationLevel'); + this.config.options.connectionIsolationLevel = config.options.connectionIsolationLevel; + } + if (config.options.connectTimeout !== undefined) { + if (typeof config.options.connectTimeout !== 'number') { + throw new TypeError('The "config.options.connectTimeout" property must be of type number.'); + } + this.config.options.connectTimeout = config.options.connectTimeout; + } + if (config.options.connector !== undefined) { + if (typeof config.options.connector !== 'function') { + throw new TypeError('The "config.options.connector" property must be a function.'); + } + this.config.options.connector = config.options.connector; + } + if (config.options.cryptoCredentialsDetails !== undefined) { + if (typeof config.options.cryptoCredentialsDetails !== 'object' || config.options.cryptoCredentialsDetails === null) { + throw new TypeError('The "config.options.cryptoCredentialsDetails" property must be of type Object.'); + } + this.config.options.cryptoCredentialsDetails = config.options.cryptoCredentialsDetails; + } + if (config.options.database !== undefined) { + if (typeof config.options.database !== 'string') { + throw new TypeError('The "config.options.database" property must be of type string.'); + } + this.config.options.database = config.options.database; + } + if (config.options.datefirst !== undefined) { + if (typeof config.options.datefirst !== 'number' && config.options.datefirst !== null) { + throw new TypeError('The "config.options.datefirst" property must be of type number.'); + } + if (config.options.datefirst !== null && (config.options.datefirst < 1 || config.options.datefirst > 7)) { + throw new RangeError('The "config.options.datefirst" property must be >= 1 and <= 7'); + } + this.config.options.datefirst = config.options.datefirst; + } + if (config.options.dateFormat !== undefined) { + if (typeof config.options.dateFormat !== 'string' && config.options.dateFormat !== null) { + throw new TypeError('The "config.options.dateFormat" property must be of type string or null.'); + } + this.config.options.dateFormat = config.options.dateFormat; + } + if (config.options.debug) { + if (config.options.debug.data !== undefined) { + if (typeof config.options.debug.data !== 'boolean') { + throw new TypeError('The "config.options.debug.data" property must be of type boolean.'); + } + this.config.options.debug.data = config.options.debug.data; + } + if (config.options.debug.packet !== undefined) { + if (typeof config.options.debug.packet !== 'boolean') { + throw new TypeError('The "config.options.debug.packet" property must be of type boolean.'); + } + this.config.options.debug.packet = config.options.debug.packet; + } + if (config.options.debug.payload !== undefined) { + if (typeof config.options.debug.payload !== 'boolean') { + throw new TypeError('The "config.options.debug.payload" property must be of type boolean.'); + } + this.config.options.debug.payload = config.options.debug.payload; + } + if (config.options.debug.token !== undefined) { + if (typeof config.options.debug.token !== 'boolean') { + throw new TypeError('The "config.options.debug.token" property must be of type boolean.'); + } + this.config.options.debug.token = config.options.debug.token; + } + } + if (config.options.enableAnsiNull !== undefined) { + if (typeof config.options.enableAnsiNull !== 'boolean' && config.options.enableAnsiNull !== null) { + throw new TypeError('The "config.options.enableAnsiNull" property must be of type boolean or null.'); + } + this.config.options.enableAnsiNull = config.options.enableAnsiNull; + } + if (config.options.enableAnsiNullDefault !== undefined) { + if (typeof config.options.enableAnsiNullDefault !== 'boolean' && config.options.enableAnsiNullDefault !== null) { + throw new TypeError('The "config.options.enableAnsiNullDefault" property must be of type boolean or null.'); + } + this.config.options.enableAnsiNullDefault = config.options.enableAnsiNullDefault; + } + if (config.options.enableAnsiPadding !== undefined) { + if (typeof config.options.enableAnsiPadding !== 'boolean' && config.options.enableAnsiPadding !== null) { + throw new TypeError('The "config.options.enableAnsiPadding" property must be of type boolean or null.'); + } + this.config.options.enableAnsiPadding = config.options.enableAnsiPadding; + } + if (config.options.enableAnsiWarnings !== undefined) { + if (typeof config.options.enableAnsiWarnings !== 'boolean' && config.options.enableAnsiWarnings !== null) { + throw new TypeError('The "config.options.enableAnsiWarnings" property must be of type boolean or null.'); + } + this.config.options.enableAnsiWarnings = config.options.enableAnsiWarnings; + } + if (config.options.enableArithAbort !== undefined) { + if (typeof config.options.enableArithAbort !== 'boolean' && config.options.enableArithAbort !== null) { + throw new TypeError('The "config.options.enableArithAbort" property must be of type boolean or null.'); + } + this.config.options.enableArithAbort = config.options.enableArithAbort; + } + if (config.options.enableConcatNullYieldsNull !== undefined) { + if (typeof config.options.enableConcatNullYieldsNull !== 'boolean' && config.options.enableConcatNullYieldsNull !== null) { + throw new TypeError('The "config.options.enableConcatNullYieldsNull" property must be of type boolean or null.'); + } + this.config.options.enableConcatNullYieldsNull = config.options.enableConcatNullYieldsNull; + } + if (config.options.enableCursorCloseOnCommit !== undefined) { + if (typeof config.options.enableCursorCloseOnCommit !== 'boolean' && config.options.enableCursorCloseOnCommit !== null) { + throw new TypeError('The "config.options.enableCursorCloseOnCommit" property must be of type boolean or null.'); + } + this.config.options.enableCursorCloseOnCommit = config.options.enableCursorCloseOnCommit; + } + if (config.options.enableImplicitTransactions !== undefined) { + if (typeof config.options.enableImplicitTransactions !== 'boolean' && config.options.enableImplicitTransactions !== null) { + throw new TypeError('The "config.options.enableImplicitTransactions" property must be of type boolean or null.'); + } + this.config.options.enableImplicitTransactions = config.options.enableImplicitTransactions; + } + if (config.options.enableNumericRoundabort !== undefined) { + if (typeof config.options.enableNumericRoundabort !== 'boolean' && config.options.enableNumericRoundabort !== null) { + throw new TypeError('The "config.options.enableNumericRoundabort" property must be of type boolean or null.'); + } + this.config.options.enableNumericRoundabort = config.options.enableNumericRoundabort; + } + if (config.options.enableQuotedIdentifier !== undefined) { + if (typeof config.options.enableQuotedIdentifier !== 'boolean' && config.options.enableQuotedIdentifier !== null) { + throw new TypeError('The "config.options.enableQuotedIdentifier" property must be of type boolean or null.'); + } + this.config.options.enableQuotedIdentifier = config.options.enableQuotedIdentifier; + } + if (config.options.encrypt !== undefined) { + if (typeof config.options.encrypt !== 'boolean') { + if (config.options.encrypt !== 'strict') { + throw new TypeError('The "encrypt" property must be set to "strict", or of type boolean.'); + } + } + this.config.options.encrypt = config.options.encrypt; + } + if (config.options.fallbackToDefaultDb !== undefined) { + if (typeof config.options.fallbackToDefaultDb !== 'boolean') { + throw new TypeError('The "config.options.fallbackToDefaultDb" property must be of type boolean.'); + } + this.config.options.fallbackToDefaultDb = config.options.fallbackToDefaultDb; + } + if (config.options.instanceName !== undefined) { + if (typeof config.options.instanceName !== 'string') { + throw new TypeError('The "config.options.instanceName" property must be of type string.'); + } + this.config.options.instanceName = config.options.instanceName; + this.config.options.port = undefined; + } + if (config.options.isolationLevel !== undefined) { + (0, _transaction.assertValidIsolationLevel)(config.options.isolationLevel, 'config.options.isolationLevel'); + this.config.options.isolationLevel = config.options.isolationLevel; + } + if (config.options.language !== undefined) { + if (typeof config.options.language !== 'string' && config.options.language !== null) { + throw new TypeError('The "config.options.language" property must be of type string or null.'); + } + this.config.options.language = config.options.language; + } + if (config.options.localAddress !== undefined) { + if (typeof config.options.localAddress !== 'string') { + throw new TypeError('The "config.options.localAddress" property must be of type string.'); + } + this.config.options.localAddress = config.options.localAddress; + } + if (config.options.multiSubnetFailover !== undefined) { + if (typeof config.options.multiSubnetFailover !== 'boolean') { + throw new TypeError('The "config.options.multiSubnetFailover" property must be of type boolean.'); + } + this.config.options.multiSubnetFailover = config.options.multiSubnetFailover; + } + if (config.options.packetSize !== undefined) { + if (typeof config.options.packetSize !== 'number') { + throw new TypeError('The "config.options.packetSize" property must be of type number.'); + } + this.config.options.packetSize = config.options.packetSize; + } + if (config.options.port !== undefined) { + if (typeof config.options.port !== 'number') { + throw new TypeError('The "config.options.port" property must be of type number.'); + } + if (config.options.port <= 0 || config.options.port >= 65536) { + throw new RangeError('The "config.options.port" property must be > 0 and < 65536'); + } + this.config.options.port = config.options.port; + this.config.options.instanceName = undefined; + } + if (config.options.readOnlyIntent !== undefined) { + if (typeof config.options.readOnlyIntent !== 'boolean') { + throw new TypeError('The "config.options.readOnlyIntent" property must be of type boolean.'); + } + this.config.options.readOnlyIntent = config.options.readOnlyIntent; + } + if (config.options.requestTimeout !== undefined) { + if (typeof config.options.requestTimeout !== 'number') { + throw new TypeError('The "config.options.requestTimeout" property must be of type number.'); + } + this.config.options.requestTimeout = config.options.requestTimeout; + } + if (config.options.maxRetriesOnTransientErrors !== undefined) { + if (typeof config.options.maxRetriesOnTransientErrors !== 'number') { + throw new TypeError('The "config.options.maxRetriesOnTransientErrors" property must be of type number.'); + } + if (config.options.maxRetriesOnTransientErrors < 0) { + throw new TypeError('The "config.options.maxRetriesOnTransientErrors" property must be equal or greater than 0.'); + } + this.config.options.maxRetriesOnTransientErrors = config.options.maxRetriesOnTransientErrors; + } + if (config.options.connectionRetryInterval !== undefined) { + if (typeof config.options.connectionRetryInterval !== 'number') { + throw new TypeError('The "config.options.connectionRetryInterval" property must be of type number.'); + } + if (config.options.connectionRetryInterval <= 0) { + throw new TypeError('The "config.options.connectionRetryInterval" property must be greater than 0.'); + } + this.config.options.connectionRetryInterval = config.options.connectionRetryInterval; + } + if (config.options.rowCollectionOnDone !== undefined) { + if (typeof config.options.rowCollectionOnDone !== 'boolean') { + throw new TypeError('The "config.options.rowCollectionOnDone" property must be of type boolean.'); + } + this.config.options.rowCollectionOnDone = config.options.rowCollectionOnDone; + } + if (config.options.rowCollectionOnRequestCompletion !== undefined) { + if (typeof config.options.rowCollectionOnRequestCompletion !== 'boolean') { + throw new TypeError('The "config.options.rowCollectionOnRequestCompletion" property must be of type boolean.'); + } + this.config.options.rowCollectionOnRequestCompletion = config.options.rowCollectionOnRequestCompletion; + } + if (config.options.tdsVersion !== undefined) { + if (typeof config.options.tdsVersion !== 'string') { + throw new TypeError('The "config.options.tdsVersion" property must be of type string.'); + } + this.config.options.tdsVersion = config.options.tdsVersion; + } + if (config.options.textsize !== undefined) { + if (typeof config.options.textsize !== 'number' && config.options.textsize !== null) { + throw new TypeError('The "config.options.textsize" property must be of type number or null.'); + } + if (config.options.textsize > 2147483647) { + throw new TypeError('The "config.options.textsize" can\'t be greater than 2147483647.'); + } else if (config.options.textsize < -1) { + throw new TypeError('The "config.options.textsize" can\'t be smaller than -1.'); + } + this.config.options.textsize = config.options.textsize | 0; + } + if (config.options.trustServerCertificate !== undefined) { + if (typeof config.options.trustServerCertificate !== 'boolean') { + throw new TypeError('The "config.options.trustServerCertificate" property must be of type boolean.'); + } + this.config.options.trustServerCertificate = config.options.trustServerCertificate; + } + if (config.options.serverName !== undefined) { + if (typeof config.options.serverName !== 'string') { + throw new TypeError('The "config.options.serverName" property must be of type string.'); + } + this.config.options.serverName = config.options.serverName; + } + if (config.options.useColumnNames !== undefined) { + if (typeof config.options.useColumnNames !== 'boolean') { + throw new TypeError('The "config.options.useColumnNames" property must be of type boolean.'); + } + this.config.options.useColumnNames = config.options.useColumnNames; + } + if (config.options.useUTC !== undefined) { + if (typeof config.options.useUTC !== 'boolean') { + throw new TypeError('The "config.options.useUTC" property must be of type boolean.'); + } + this.config.options.useUTC = config.options.useUTC; + } + if (config.options.workstationId !== undefined) { + if (typeof config.options.workstationId !== 'string') { + throw new TypeError('The "config.options.workstationId" property must be of type string.'); + } + this.config.options.workstationId = config.options.workstationId; + } + if (config.options.lowerCaseGuids !== undefined) { + if (typeof config.options.lowerCaseGuids !== 'boolean') { + throw new TypeError('The "config.options.lowerCaseGuids" property must be of type boolean.'); + } + this.config.options.lowerCaseGuids = config.options.lowerCaseGuids; + } + } + this.secureContextOptions = this.config.options.cryptoCredentialsDetails; + if (this.secureContextOptions.secureOptions === undefined) { + // If the caller has not specified their own `secureOptions`, + // we set `SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS` here. + // Older SQL Server instances running on older Windows versions have + // trouble with the BEAST workaround in OpenSSL. + // As BEAST is a browser specific exploit, we can just disable this option here. + this.secureContextOptions = Object.create(this.secureContextOptions, { + secureOptions: { + value: _constants.default.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS + } + }); + } + this.debug = this.createDebug(); + this.inTransaction = false; + this.transactionDescriptors = [Buffer.from([0, 0, 0, 0, 0, 0, 0, 0])]; + + // 'beginTransaction', 'commitTransaction' and 'rollbackTransaction' + // events are utilized to maintain inTransaction property state which in + // turn is used in managing transactions. These events are only fired for + // TDS version 7.2 and beyond. The properties below are used to emulate + // equivalent behavior for TDS versions before 7.2. + this.transactionDepth = 0; + this.isSqlBatch = false; + this.closed = false; + this.messageBuffer = Buffer.alloc(0); + this.curTransientRetryCount = 0; + this.transientErrorLookup = new _transientErrorLookup.TransientErrorLookup(); + this.state = this.STATE.INITIALIZED; + this._cancelAfterRequestSent = () => { + this.messageIo.sendMessage(_packet.TYPE.ATTENTION); + this.createCancelTimer(); + }; + } + connect(connectListener) { + if (this.state !== this.STATE.INITIALIZED) { + throw new _errors.ConnectionError('`.connect` can not be called on a Connection in `' + this.state.name + '` state.'); + } + if (connectListener) { + const onConnect = err => { + this.removeListener('error', onError); + connectListener(err); + }; + const onError = err => { + this.removeListener('connect', onConnect); + connectListener(err); + }; + this.once('connect', onConnect); + this.once('error', onError); + } + this.transitionTo(this.STATE.CONNECTING); + } + + /** + * The server has reported that the charset has changed. + */ + + /** + * The attempt to connect and validate has completed. + */ + + /** + * The server has reported that the active database has changed. + * This may be as a result of a successful login, or a `use` statement. + */ + + /** + * A debug message is available. It may be logged or ignored. + */ + + /** + * Internal error occurs. + */ + + /** + * The server has issued an error message. + */ + + /** + * The connection has ended. + * + * This may be as a result of the client calling [[close]], the server + * closing the connection, or a network error. + */ + + /** + * The server has issued an information message. + */ + + /** + * The server has reported that the language has changed. + */ + + /** + * The connection was reset. + */ + + /** + * A secure connection has been established. + */ + + on(event, listener) { + return super.on(event, listener); + } + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + /** + * @private + */ + + emit(event, ...args) { + return super.emit(event, ...args); + } + + /** + * Closes the connection to the database. + * + * The [[Event_end]] will be emitted once the connection has been closed. + */ + close() { + this.transitionTo(this.STATE.FINAL); + } + + /** + * @private + */ + initialiseConnection() { + const signal = this.createConnectTimer(); + if (this.config.options.port) { + return this.connectOnPort(this.config.options.port, this.config.options.multiSubnetFailover, signal, this.config.options.connector); + } else { + return (0, _instanceLookup.instanceLookup)({ + server: this.config.server, + instanceName: this.config.options.instanceName, + timeout: this.config.options.connectTimeout, + signal: signal + }).then(port => { + process.nextTick(() => { + this.connectOnPort(port, this.config.options.multiSubnetFailover, signal, this.config.options.connector); + }); + }, err => { + this.clearConnectTimer(); + if (signal.aborted) { + // Ignore the AbortError for now, this is still handled by the connectTimer firing + return; + } + process.nextTick(() => { + this.emit('connect', new _errors.ConnectionError(err.message, 'EINSTLOOKUP')); + }); + }); + } + } + + /** + * @private + */ + cleanupConnection(cleanupType) { + if (!this.closed) { + this.clearConnectTimer(); + this.clearRequestTimer(); + this.clearRetryTimer(); + this.closeConnection(); + if (cleanupType === CLEANUP_TYPE.REDIRECT) { + this.emit('rerouting'); + } else if (cleanupType !== CLEANUP_TYPE.RETRY) { + process.nextTick(() => { + this.emit('end'); + }); + } + const request = this.request; + if (request) { + const err = new _errors.RequestError('Connection closed before request completed.', 'ECLOSE'); + request.callback(err); + this.request = undefined; + } + this.closed = true; + this.loginError = undefined; + } + } + + /** + * @private + */ + createDebug() { + const debug = new _debug.default(this.config.options.debug); + debug.on('debug', message => { + this.emit('debug', message); + }); + return debug; + } + + /** + * @private + */ + createTokenStreamParser(message, handler) { + return new _tokenStreamParser.Parser(message, this.debug, handler, this.config.options); + } + socketHandlingForSendPreLogin(socket) { + socket.on('error', error => { + this.socketError(error); + }); + socket.on('close', () => { + this.socketClose(); + }); + socket.on('end', () => { + this.socketEnd(); + }); + socket.setKeepAlive(true, KEEP_ALIVE_INITIAL_DELAY); + this.messageIo = new _messageIo.default(socket, this.config.options.packetSize, this.debug); + this.messageIo.on('secure', cleartext => { + this.emit('secure', cleartext); + }); + this.socket = socket; + this.closed = false; + this.debug.log('connected to ' + this.config.server + ':' + this.config.options.port); + this.sendPreLogin(); + this.transitionTo(this.STATE.SENT_PRELOGIN); + } + wrapWithTls(socket, signal) { + signal.throwIfAborted(); + return new Promise((resolve, reject) => { + const secureContext = tls.createSecureContext(this.secureContextOptions); + // If connect to an ip address directly, + // need to set the servername to an empty string + // if the user has not given a servername explicitly + const serverName = !net.isIP(this.config.server) ? this.config.server : ''; + const encryptOptions = { + host: this.config.server, + socket: socket, + ALPNProtocols: ['tds/8.0'], + secureContext: secureContext, + servername: this.config.options.serverName ? this.config.options.serverName : serverName + }; + const encryptsocket = tls.connect(encryptOptions); + const onAbort = () => { + encryptsocket.removeListener('error', onError); + encryptsocket.removeListener('connect', onConnect); + encryptsocket.destroy(); + reject(signal.reason); + }; + const onError = err => { + signal.removeEventListener('abort', onAbort); + encryptsocket.removeListener('error', onError); + encryptsocket.removeListener('connect', onConnect); + encryptsocket.destroy(); + reject(err); + }; + const onConnect = () => { + signal.removeEventListener('abort', onAbort); + encryptsocket.removeListener('error', onError); + encryptsocket.removeListener('connect', onConnect); + resolve(encryptsocket); + }; + signal.addEventListener('abort', onAbort, { + once: true + }); + encryptsocket.on('error', onError); + encryptsocket.on('secureConnect', onConnect); + }); + } + connectOnPort(port, multiSubnetFailover, signal, customConnector) { + const connectOpts = { + host: this.routingData ? this.routingData.server : this.config.server, + port: this.routingData ? this.routingData.port : port, + localAddress: this.config.options.localAddress + }; + const connect = customConnector || (multiSubnetFailover ? _connector.connectInParallel : _connector.connectInSequence); + (async () => { + let socket = await connect(connectOpts, _dns.default.lookup, signal); + if (this.config.options.encrypt === 'strict') { + try { + // Wrap the socket with TLS for TDS 8.0 + socket = await this.wrapWithTls(socket, signal); + } catch (err) { + socket.end(); + throw err; + } + } + this.socketHandlingForSendPreLogin(socket); + })().catch(err => { + this.clearConnectTimer(); + if (signal.aborted) { + return; + } + process.nextTick(() => { + this.socketError(err); + }); + }); + } + + /** + * @private + */ + closeConnection() { + if (this.socket) { + this.socket.destroy(); + } + } + + /** + * @private + */ + createConnectTimer() { + const controller = new _nodeAbortController.AbortController(); + this.connectTimer = setTimeout(() => { + controller.abort(); + this.connectTimeout(); + }, this.config.options.connectTimeout); + return controller.signal; + } + + /** + * @private + */ + createCancelTimer() { + this.clearCancelTimer(); + const timeout = this.config.options.cancelTimeout; + if (timeout > 0) { + this.cancelTimer = setTimeout(() => { + this.cancelTimeout(); + }, timeout); + } + } + + /** + * @private + */ + createRequestTimer() { + this.clearRequestTimer(); // release old timer, just to be safe + const request = this.request; + const timeout = request.timeout !== undefined ? request.timeout : this.config.options.requestTimeout; + if (timeout) { + this.requestTimer = setTimeout(() => { + this.requestTimeout(); + }, timeout); + } + } + + /** + * @private + */ + createRetryTimer() { + this.clearRetryTimer(); + this.retryTimer = setTimeout(() => { + this.retryTimeout(); + }, this.config.options.connectionRetryInterval); + } + + /** + * @private + */ + connectTimeout() { + const hostPostfix = this.config.options.port ? `:${this.config.options.port}` : `\\${this.config.options.instanceName}`; + // If we have routing data stored, this connection has been redirected + const server = this.routingData ? this.routingData.server : this.config.server; + const port = this.routingData ? `:${this.routingData.port}` : hostPostfix; + // Grab the target host from the connection configuration, and from a redirect message + // otherwise, leave the message empty. + const routingMessage = this.routingData ? ` (redirected from ${this.config.server}${hostPostfix})` : ''; + const message = `Failed to connect to ${server}${port}${routingMessage} in ${this.config.options.connectTimeout}ms`; + this.debug.log(message); + this.emit('connect', new _errors.ConnectionError(message, 'ETIMEOUT')); + this.connectTimer = undefined; + this.dispatchEvent('connectTimeout'); + } + + /** + * @private + */ + cancelTimeout() { + const message = `Failed to cancel request in ${this.config.options.cancelTimeout}ms`; + this.debug.log(message); + this.dispatchEvent('socketError', new _errors.ConnectionError(message, 'ETIMEOUT')); + } + + /** + * @private + */ + requestTimeout() { + this.requestTimer = undefined; + const request = this.request; + request.cancel(); + const timeout = request.timeout !== undefined ? request.timeout : this.config.options.requestTimeout; + const message = 'Timeout: Request failed to complete in ' + timeout + 'ms'; + request.error = new _errors.RequestError(message, 'ETIMEOUT'); + } + + /** + * @private + */ + retryTimeout() { + this.retryTimer = undefined; + this.emit('retry'); + this.transitionTo(this.STATE.CONNECTING); + } + + /** + * @private + */ + clearConnectTimer() { + if (this.connectTimer) { + clearTimeout(this.connectTimer); + this.connectTimer = undefined; + } + } + + /** + * @private + */ + clearCancelTimer() { + if (this.cancelTimer) { + clearTimeout(this.cancelTimer); + this.cancelTimer = undefined; + } + } + + /** + * @private + */ + clearRequestTimer() { + if (this.requestTimer) { + clearTimeout(this.requestTimer); + this.requestTimer = undefined; + } + } + + /** + * @private + */ + clearRetryTimer() { + if (this.retryTimer) { + clearTimeout(this.retryTimer); + this.retryTimer = undefined; + } + } + + /** + * @private + */ + transitionTo(newState) { + if (this.state === newState) { + this.debug.log('State is already ' + newState.name); + return; + } + if (this.state && this.state.exit) { + this.state.exit.call(this, newState); + } + this.debug.log('State change: ' + (this.state ? this.state.name : 'undefined') + ' -> ' + newState.name); + this.state = newState; + if (this.state.enter) { + this.state.enter.apply(this); + } + } + + /** + * @private + */ + getEventHandler(eventName) { + const handler = this.state.events[eventName]; + if (!handler) { + throw new Error(`No event '${eventName}' in state '${this.state.name}'`); + } + return handler; + } + + /** + * @private + */ + dispatchEvent(eventName, ...args) { + const handler = this.state.events[eventName]; + if (handler) { + handler.apply(this, args); + } else { + this.emit('error', new Error(`No event '${eventName}' in state '${this.state.name}'`)); + this.close(); + } + } + + /** + * @private + */ + socketError(error) { + if (this.state === this.STATE.CONNECTING || this.state === this.STATE.SENT_TLSSSLNEGOTIATION) { + const hostPostfix = this.config.options.port ? `:${this.config.options.port}` : `\\${this.config.options.instanceName}`; + // If we have routing data stored, this connection has been redirected + const server = this.routingData ? this.routingData.server : this.config.server; + const port = this.routingData ? `:${this.routingData.port}` : hostPostfix; + // Grab the target host from the connection configuration, and from a redirect message + // otherwise, leave the message empty. + const routingMessage = this.routingData ? ` (redirected from ${this.config.server}${hostPostfix})` : ''; + const message = `Failed to connect to ${server}${port}${routingMessage} - ${error.message}`; + this.debug.log(message); + this.emit('connect', new _errors.ConnectionError(message, 'ESOCKET')); + } else { + const message = `Connection lost - ${error.message}`; + this.debug.log(message); + this.emit('error', new _errors.ConnectionError(message, 'ESOCKET')); + } + this.dispatchEvent('socketError', error); + } + + /** + * @private + */ + socketEnd() { + this.debug.log('socket ended'); + if (this.state !== this.STATE.FINAL) { + const error = new Error('socket hang up'); + error.code = 'ECONNRESET'; + this.socketError(error); + } + } + + /** + * @private + */ + socketClose() { + this.debug.log('connection to ' + this.config.server + ':' + this.config.options.port + ' closed'); + if (this.state === this.STATE.REROUTING) { + this.debug.log('Rerouting to ' + this.routingData.server + ':' + this.routingData.port); + this.dispatchEvent('reconnect'); + } else if (this.state === this.STATE.TRANSIENT_FAILURE_RETRY) { + const server = this.routingData ? this.routingData.server : this.config.server; + const port = this.routingData ? this.routingData.port : this.config.options.port; + this.debug.log('Retry after transient failure connecting to ' + server + ':' + port); + this.dispatchEvent('retry'); + } else { + this.transitionTo(this.STATE.FINAL); + } + } + + /** + * @private + */ + sendPreLogin() { + const [, major, minor, build] = /^(\d+)\.(\d+)\.(\d+)/.exec(_package.version) ?? ['0.0.0', '0', '0', '0']; + const payload = new _preloginPayload.default({ + // If encrypt setting is set to 'strict', then we should have already done the encryption before calling + // this function. Therefore, the encrypt will be set to false here. + // Otherwise, we will set encrypt here based on the encrypt Boolean value from the configuration. + encrypt: typeof this.config.options.encrypt === 'boolean' && this.config.options.encrypt, + version: { + major: Number(major), + minor: Number(minor), + build: Number(build), + subbuild: 0 + } + }); + this.messageIo.sendMessage(_packet.TYPE.PRELOGIN, payload.data); + this.debug.payload(function () { + return payload.toString(' '); + }); + } + + /** + * @private + */ + sendLogin7Packet() { + const payload = new _login7Payload.default({ + tdsVersion: _tdsVersions.versions[this.config.options.tdsVersion], + packetSize: this.config.options.packetSize, + clientProgVer: 0, + clientPid: process.pid, + connectionId: 0, + clientTimeZone: new Date().getTimezoneOffset(), + clientLcid: 0x00000409 + }); + const { + authentication + } = this.config; + switch (authentication.type) { + case 'azure-active-directory-password': + payload.fedAuth = { + type: 'ADAL', + echo: this.fedAuthRequired, + workflow: 'default' + }; + break; + case 'azure-active-directory-access-token': + payload.fedAuth = { + type: 'SECURITYTOKEN', + echo: this.fedAuthRequired, + fedAuthToken: authentication.options.token + }; + break; + case 'azure-active-directory-msi-vm': + case 'azure-active-directory-default': + case 'azure-active-directory-msi-app-service': + case 'azure-active-directory-service-principal-secret': + payload.fedAuth = { + type: 'ADAL', + echo: this.fedAuthRequired, + workflow: 'integrated' + }; + break; + case 'ntlm': + payload.sspi = (0, _ntlm.createNTLMRequest)({ + domain: authentication.options.domain + }); + break; + default: + payload.userName = authentication.options.userName; + payload.password = authentication.options.password; + } + payload.hostname = this.config.options.workstationId || _os.default.hostname(); + payload.serverName = this.routingData ? this.routingData.server : this.config.server; + payload.appName = this.config.options.appName || 'Tedious'; + payload.libraryName = _library.name; + payload.language = this.config.options.language; + payload.database = this.config.options.database; + payload.clientId = Buffer.from([1, 2, 3, 4, 5, 6]); + payload.readOnlyIntent = this.config.options.readOnlyIntent; + payload.initDbFatal = !this.config.options.fallbackToDefaultDb; + this.routingData = undefined; + this.messageIo.sendMessage(_packet.TYPE.LOGIN7, payload.toBuffer()); + this.debug.payload(function () { + return payload.toString(' '); + }); + } + + /** + * @private + */ + sendFedAuthTokenMessage(token) { + const accessTokenLen = Buffer.byteLength(token, 'ucs2'); + const data = Buffer.alloc(8 + accessTokenLen); + let offset = 0; + offset = data.writeUInt32LE(accessTokenLen + 4, offset); + offset = data.writeUInt32LE(accessTokenLen, offset); + data.write(token, offset, 'ucs2'); + this.messageIo.sendMessage(_packet.TYPE.FEDAUTH_TOKEN, data); + // sent the fedAuth token message, the rest is similar to standard login 7 + this.transitionTo(this.STATE.SENT_LOGIN7_WITH_STANDARD_LOGIN); + } + + /** + * @private + */ + sendInitialSql() { + const payload = new _sqlbatchPayload.default(this.getInitialSql(), this.currentTransactionDescriptor(), this.config.options); + const message = new _message.default({ + type: _packet.TYPE.SQL_BATCH + }); + this.messageIo.outgoingMessageStream.write(message); + _stream.Readable.from(payload).pipe(message); + } + + /** + * @private + */ + getInitialSql() { + const options = []; + if (this.config.options.enableAnsiNull === true) { + options.push('set ansi_nulls on'); + } else if (this.config.options.enableAnsiNull === false) { + options.push('set ansi_nulls off'); + } + if (this.config.options.enableAnsiNullDefault === true) { + options.push('set ansi_null_dflt_on on'); + } else if (this.config.options.enableAnsiNullDefault === false) { + options.push('set ansi_null_dflt_on off'); + } + if (this.config.options.enableAnsiPadding === true) { + options.push('set ansi_padding on'); + } else if (this.config.options.enableAnsiPadding === false) { + options.push('set ansi_padding off'); + } + if (this.config.options.enableAnsiWarnings === true) { + options.push('set ansi_warnings on'); + } else if (this.config.options.enableAnsiWarnings === false) { + options.push('set ansi_warnings off'); + } + if (this.config.options.enableArithAbort === true) { + options.push('set arithabort on'); + } else if (this.config.options.enableArithAbort === false) { + options.push('set arithabort off'); + } + if (this.config.options.enableConcatNullYieldsNull === true) { + options.push('set concat_null_yields_null on'); + } else if (this.config.options.enableConcatNullYieldsNull === false) { + options.push('set concat_null_yields_null off'); + } + if (this.config.options.enableCursorCloseOnCommit === true) { + options.push('set cursor_close_on_commit on'); + } else if (this.config.options.enableCursorCloseOnCommit === false) { + options.push('set cursor_close_on_commit off'); + } + if (this.config.options.datefirst !== null) { + options.push(`set datefirst ${this.config.options.datefirst}`); + } + if (this.config.options.dateFormat !== null) { + options.push(`set dateformat ${this.config.options.dateFormat}`); + } + if (this.config.options.enableImplicitTransactions === true) { + options.push('set implicit_transactions on'); + } else if (this.config.options.enableImplicitTransactions === false) { + options.push('set implicit_transactions off'); + } + if (this.config.options.language !== null) { + options.push(`set language ${this.config.options.language}`); + } + if (this.config.options.enableNumericRoundabort === true) { + options.push('set numeric_roundabort on'); + } else if (this.config.options.enableNumericRoundabort === false) { + options.push('set numeric_roundabort off'); + } + if (this.config.options.enableQuotedIdentifier === true) { + options.push('set quoted_identifier on'); + } else if (this.config.options.enableQuotedIdentifier === false) { + options.push('set quoted_identifier off'); + } + if (this.config.options.textsize !== null) { + options.push(`set textsize ${this.config.options.textsize}`); + } + if (this.config.options.connectionIsolationLevel !== null) { + options.push(`set transaction isolation level ${this.getIsolationLevelText(this.config.options.connectionIsolationLevel)}`); + } + if (this.config.options.abortTransactionOnError === true) { + options.push('set xact_abort on'); + } else if (this.config.options.abortTransactionOnError === false) { + options.push('set xact_abort off'); + } + return options.join('\n'); + } + + /** + * @private + */ + processedInitialSql() { + this.clearConnectTimer(); + this.emit('connect'); + } + + /** + * Execute the SQL batch represented by [[Request]]. + * There is no param support, and unlike [[Request.execSql]], + * it is not likely that SQL Server will reuse the execution plan it generates for the SQL. + * + * In almost all cases, [[Request.execSql]] will be a better choice. + * + * @param request A [[Request]] object representing the request. + */ + execSqlBatch(request) { + this.makeRequest(request, _packet.TYPE.SQL_BATCH, new _sqlbatchPayload.default(request.sqlTextOrProcedure, this.currentTransactionDescriptor(), this.config.options)); + } + + /** + * Execute the SQL represented by [[Request]]. + * + * As `sp_executesql` is used to execute the SQL, if the same SQL is executed multiples times + * using this function, the SQL Server query optimizer is likely to reuse the execution plan it generates + * for the first execution. This may also result in SQL server treating the request like a stored procedure + * which can result in the [[Event_doneInProc]] or [[Event_doneProc]] events being emitted instead of the + * [[Event_done]] event you might expect. Using [[execSqlBatch]] will prevent this from occurring but may have a negative performance impact. + * + * Beware of the way that scoping rules apply, and how they may [affect local temp tables](http://weblogs.sqlteam.com/mladenp/archive/2006/11/03/17197.aspx) + * If you're running in to scoping issues, then [[execSqlBatch]] may be a better choice. + * See also [issue #24](https://github.com/pekim/tedious/issues/24) + * + * @param request A [[Request]] object representing the request. + */ + execSql(request) { + try { + request.validateParameters(this.databaseCollation); + } catch (error) { + request.error = error; + process.nextTick(() => { + this.debug.log(error.message); + request.callback(error); + }); + return; + } + const parameters = []; + parameters.push({ + type: _dataType.TYPES.NVarChar, + name: 'statement', + value: request.sqlTextOrProcedure, + output: false, + length: undefined, + precision: undefined, + scale: undefined + }); + if (request.parameters.length) { + parameters.push({ + type: _dataType.TYPES.NVarChar, + name: 'params', + value: request.makeParamsParameter(request.parameters), + output: false, + length: undefined, + precision: undefined, + scale: undefined + }); + parameters.push(...request.parameters); + } + this.makeRequest(request, _packet.TYPE.RPC_REQUEST, new _rpcrequestPayload.default(_specialStoredProcedure.default.Sp_ExecuteSql, parameters, this.currentTransactionDescriptor(), this.config.options, this.databaseCollation)); + } + + /** + * Creates a new BulkLoad instance. + * + * @param table The name of the table to bulk-insert into. + * @param options A set of bulk load options. + */ + + newBulkLoad(table, callbackOrOptions, callback) { + let options; + if (callback === undefined) { + callback = callbackOrOptions; + options = {}; + } else { + options = callbackOrOptions; + } + if (typeof options !== 'object') { + throw new TypeError('"options" argument must be an object'); + } + return new _bulkLoad.default(table, this.databaseCollation, this.config.options, options, callback); + } + + /** + * Execute a [[BulkLoad]]. + * + * ```js + * // We want to perform a bulk load into a table with the following format: + * // CREATE TABLE employees (first_name nvarchar(255), last_name nvarchar(255), day_of_birth date); + * + * const bulkLoad = connection.newBulkLoad('employees', (err, rowCount) => { + * // ... + * }); + * + * // First, we need to specify the columns that we want to write to, + * // and their definitions. These definitions must match the actual table, + * // otherwise the bulk load will fail. + * bulkLoad.addColumn('first_name', TYPES.NVarchar, { nullable: false }); + * bulkLoad.addColumn('last_name', TYPES.NVarchar, { nullable: false }); + * bulkLoad.addColumn('date_of_birth', TYPES.Date, { nullable: false }); + * + * // Execute a bulk load with a predefined list of rows. + * // + * // Note that these rows are held in memory until the + * // bulk load was performed, so if you need to write a large + * // number of rows (e.g. by reading from a CSV file), + * // passing an `AsyncIterable` is advisable to keep memory usage low. + * connection.execBulkLoad(bulkLoad, [ + * { 'first_name': 'Steve', 'last_name': 'Jobs', 'day_of_birth': new Date('02-24-1955') }, + * { 'first_name': 'Bill', 'last_name': 'Gates', 'day_of_birth': new Date('10-28-1955') } + * ]); + * ``` + * + * @param bulkLoad A previously created [[BulkLoad]]. + * @param rows A [[Iterable]] or [[AsyncIterable]] that contains the rows that should be bulk loaded. + */ + + execBulkLoad(bulkLoad, rows) { + bulkLoad.executionStarted = true; + if (rows) { + if (bulkLoad.streamingMode) { + throw new Error("Connection.execBulkLoad can't be called with a BulkLoad that was put in streaming mode."); + } + if (bulkLoad.firstRowWritten) { + throw new Error("Connection.execBulkLoad can't be called with a BulkLoad that already has rows written to it."); + } + const rowStream = _stream.Readable.from(rows); + + // Destroy the packet transform if an error happens in the row stream, + // e.g. if an error is thrown from within a generator or stream. + rowStream.on('error', err => { + bulkLoad.rowToPacketTransform.destroy(err); + }); + + // Destroy the row stream if an error happens in the packet transform, + // e.g. if the bulk load is cancelled. + bulkLoad.rowToPacketTransform.on('error', err => { + rowStream.destroy(err); + }); + rowStream.pipe(bulkLoad.rowToPacketTransform); + } else if (!bulkLoad.streamingMode) { + // If the bulkload was not put into streaming mode by the user, + // we end the rowToPacketTransform here for them. + // + // If it was put into streaming mode, it's the user's responsibility + // to end the stream. + bulkLoad.rowToPacketTransform.end(); + } + const onCancel = () => { + request.cancel(); + }; + const payload = new _bulkLoadPayload.BulkLoadPayload(bulkLoad); + const request = new _request.default(bulkLoad.getBulkInsertSql(), error => { + bulkLoad.removeListener('cancel', onCancel); + if (error) { + if (error.code === 'UNKNOWN') { + error.message += ' This is likely because the schema of the BulkLoad does not match the schema of the table you are attempting to insert into.'; + } + bulkLoad.error = error; + bulkLoad.callback(error); + return; + } + this.makeRequest(bulkLoad, _packet.TYPE.BULK_LOAD, payload); + }); + bulkLoad.once('cancel', onCancel); + this.execSqlBatch(request); + } + + /** + * Prepare the SQL represented by the request. + * + * The request can then be used in subsequent calls to + * [[execute]] and [[unprepare]] + * + * @param request A [[Request]] object representing the request. + * Parameters only require a name and type. Parameter values are ignored. + */ + prepare(request) { + const parameters = []; + parameters.push({ + type: _dataType.TYPES.Int, + name: 'handle', + value: undefined, + output: true, + length: undefined, + precision: undefined, + scale: undefined + }); + parameters.push({ + type: _dataType.TYPES.NVarChar, + name: 'params', + value: request.parameters.length ? request.makeParamsParameter(request.parameters) : null, + output: false, + length: undefined, + precision: undefined, + scale: undefined + }); + parameters.push({ + type: _dataType.TYPES.NVarChar, + name: 'stmt', + value: request.sqlTextOrProcedure, + output: false, + length: undefined, + precision: undefined, + scale: undefined + }); + request.preparing = true; + + // TODO: We need to clean up this event handler, otherwise this leaks memory + request.on('returnValue', (name, value) => { + if (name === 'handle') { + request.handle = value; + } else { + request.error = new _errors.RequestError(`Tedious > Unexpected output parameter ${name} from sp_prepare`); + } + }); + this.makeRequest(request, _packet.TYPE.RPC_REQUEST, new _rpcrequestPayload.default(_specialStoredProcedure.default.Sp_Prepare, parameters, this.currentTransactionDescriptor(), this.config.options, this.databaseCollation)); + } + + /** + * Release the SQL Server resources associated with a previously prepared request. + * + * @param request A [[Request]] object representing the request. + * Parameters only require a name and type. + * Parameter values are ignored. + */ + unprepare(request) { + const parameters = []; + parameters.push({ + type: _dataType.TYPES.Int, + name: 'handle', + // TODO: Abort if `request.handle` is not set + value: request.handle, + output: false, + length: undefined, + precision: undefined, + scale: undefined + }); + this.makeRequest(request, _packet.TYPE.RPC_REQUEST, new _rpcrequestPayload.default(_specialStoredProcedure.default.Sp_Unprepare, parameters, this.currentTransactionDescriptor(), this.config.options, this.databaseCollation)); + } + + /** + * Execute previously prepared SQL, using the supplied parameters. + * + * @param request A previously prepared [[Request]]. + * @param parameters An object whose names correspond to the names of + * parameters that were added to the [[Request]] before it was prepared. + * The object's values are passed as the parameters' values when the + * request is executed. + */ + execute(request, parameters) { + const executeParameters = []; + executeParameters.push({ + type: _dataType.TYPES.Int, + name: '', + // TODO: Abort if `request.handle` is not set + value: request.handle, + output: false, + length: undefined, + precision: undefined, + scale: undefined + }); + try { + for (let i = 0, len = request.parameters.length; i < len; i++) { + const parameter = request.parameters[i]; + executeParameters.push({ + ...parameter, + value: parameter.type.validate(parameters ? parameters[parameter.name] : null, this.databaseCollation) + }); + } + } catch (error) { + request.error = error; + process.nextTick(() => { + this.debug.log(error.message); + request.callback(error); + }); + return; + } + this.makeRequest(request, _packet.TYPE.RPC_REQUEST, new _rpcrequestPayload.default(_specialStoredProcedure.default.Sp_Execute, executeParameters, this.currentTransactionDescriptor(), this.config.options, this.databaseCollation)); + } + + /** + * Call a stored procedure represented by [[Request]]. + * + * @param request A [[Request]] object representing the request. + */ + callProcedure(request) { + try { + request.validateParameters(this.databaseCollation); + } catch (error) { + request.error = error; + process.nextTick(() => { + this.debug.log(error.message); + request.callback(error); + }); + return; + } + this.makeRequest(request, _packet.TYPE.RPC_REQUEST, new _rpcrequestPayload.default(request.sqlTextOrProcedure, request.parameters, this.currentTransactionDescriptor(), this.config.options, this.databaseCollation)); + } + + /** + * Start a transaction. + * + * @param callback + * @param name A string representing a name to associate with the transaction. + * Optional, and defaults to an empty string. Required when `isolationLevel` + * is present. + * @param isolationLevel The isolation level that the transaction is to be run with. + * + * The isolation levels are available from `require('tedious').ISOLATION_LEVEL`. + * * `READ_UNCOMMITTED` + * * `READ_COMMITTED` + * * `REPEATABLE_READ` + * * `SERIALIZABLE` + * * `SNAPSHOT` + * + * Optional, and defaults to the Connection's isolation level. + */ + beginTransaction(callback, name = '', isolationLevel = this.config.options.isolationLevel) { + (0, _transaction.assertValidIsolationLevel)(isolationLevel, 'isolationLevel'); + const transaction = new _transaction.Transaction(name, isolationLevel); + if (this.config.options.tdsVersion < '7_2') { + return this.execSqlBatch(new _request.default('SET TRANSACTION ISOLATION LEVEL ' + transaction.isolationLevelToTSQL() + ';BEGIN TRAN ' + transaction.name, err => { + this.transactionDepth++; + if (this.transactionDepth === 1) { + this.inTransaction = true; + } + callback(err); + })); + } + const request = new _request.default(undefined, err => { + return callback(err, this.currentTransactionDescriptor()); + }); + return this.makeRequest(request, _packet.TYPE.TRANSACTION_MANAGER, transaction.beginPayload(this.currentTransactionDescriptor())); + } + + /** + * Commit a transaction. + * + * There should be an active transaction - that is, [[beginTransaction]] + * should have been previously called. + * + * @param callback + * @param name A string representing a name to associate with the transaction. + * Optional, and defaults to an empty string. Required when `isolationLevel`is present. + */ + commitTransaction(callback, name = '') { + const transaction = new _transaction.Transaction(name); + if (this.config.options.tdsVersion < '7_2') { + return this.execSqlBatch(new _request.default('COMMIT TRAN ' + transaction.name, err => { + this.transactionDepth--; + if (this.transactionDepth === 0) { + this.inTransaction = false; + } + callback(err); + })); + } + const request = new _request.default(undefined, callback); + return this.makeRequest(request, _packet.TYPE.TRANSACTION_MANAGER, transaction.commitPayload(this.currentTransactionDescriptor())); + } + + /** + * Rollback a transaction. + * + * There should be an active transaction - that is, [[beginTransaction]] + * should have been previously called. + * + * @param callback + * @param name A string representing a name to associate with the transaction. + * Optional, and defaults to an empty string. + * Required when `isolationLevel` is present. + */ + rollbackTransaction(callback, name = '') { + const transaction = new _transaction.Transaction(name); + if (this.config.options.tdsVersion < '7_2') { + return this.execSqlBatch(new _request.default('ROLLBACK TRAN ' + transaction.name, err => { + this.transactionDepth--; + if (this.transactionDepth === 0) { + this.inTransaction = false; + } + callback(err); + })); + } + const request = new _request.default(undefined, callback); + return this.makeRequest(request, _packet.TYPE.TRANSACTION_MANAGER, transaction.rollbackPayload(this.currentTransactionDescriptor())); + } + + /** + * Set a savepoint within a transaction. + * + * There should be an active transaction - that is, [[beginTransaction]] + * should have been previously called. + * + * @param callback + * @param name A string representing a name to associate with the transaction.\ + * Optional, and defaults to an empty string. + * Required when `isolationLevel` is present. + */ + saveTransaction(callback, name) { + const transaction = new _transaction.Transaction(name); + if (this.config.options.tdsVersion < '7_2') { + return this.execSqlBatch(new _request.default('SAVE TRAN ' + transaction.name, err => { + this.transactionDepth++; + callback(err); + })); + } + const request = new _request.default(undefined, callback); + return this.makeRequest(request, _packet.TYPE.TRANSACTION_MANAGER, transaction.savePayload(this.currentTransactionDescriptor())); + } + + /** + * Run the given callback after starting a transaction, and commit or + * rollback the transaction afterwards. + * + * This is a helper that employs [[beginTransaction]], [[commitTransaction]], + * [[rollbackTransaction]], and [[saveTransaction]] to greatly simplify the + * use of database transactions and automatically handle transaction nesting. + * + * @param cb + * @param isolationLevel + * The isolation level that the transaction is to be run with. + * + * The isolation levels are available from `require('tedious').ISOLATION_LEVEL`. + * * `READ_UNCOMMITTED` + * * `READ_COMMITTED` + * * `REPEATABLE_READ` + * * `SERIALIZABLE` + * * `SNAPSHOT` + * + * Optional, and defaults to the Connection's isolation level. + */ + transaction(cb, isolationLevel) { + if (typeof cb !== 'function') { + throw new TypeError('`cb` must be a function'); + } + const useSavepoint = this.inTransaction; + const name = '_tedious_' + _crypto.default.randomBytes(10).toString('hex'); + const txDone = (err, done, ...args) => { + if (err) { + if (this.inTransaction && this.state === this.STATE.LOGGED_IN) { + this.rollbackTransaction(txErr => { + done(txErr || err, ...args); + }, name); + } else { + done(err, ...args); + } + } else if (useSavepoint) { + if (this.config.options.tdsVersion < '7_2') { + this.transactionDepth--; + } + done(null, ...args); + } else { + this.commitTransaction(txErr => { + done(txErr, ...args); + }, name); + } + }; + if (useSavepoint) { + return this.saveTransaction(err => { + if (err) { + return cb(err); + } + if (isolationLevel) { + return this.execSqlBatch(new _request.default('SET transaction isolation level ' + this.getIsolationLevelText(isolationLevel), err => { + return cb(err, txDone); + })); + } else { + return cb(null, txDone); + } + }, name); + } else { + return this.beginTransaction(err => { + if (err) { + return cb(err); + } + return cb(null, txDone); + }, name, isolationLevel); + } + } + + /** + * @private + */ + makeRequest(request, packetType, payload) { + if (this.state !== this.STATE.LOGGED_IN) { + const message = 'Requests can only be made in the ' + this.STATE.LOGGED_IN.name + ' state, not the ' + this.state.name + ' state'; + this.debug.log(message); + request.callback(new _errors.RequestError(message, 'EINVALIDSTATE')); + } else if (request.canceled) { + process.nextTick(() => { + request.callback(new _errors.RequestError('Canceled.', 'ECANCEL')); + }); + } else { + if (packetType === _packet.TYPE.SQL_BATCH) { + this.isSqlBatch = true; + } else { + this.isSqlBatch = false; + } + this.request = request; + request.connection = this; + request.rowCount = 0; + request.rows = []; + request.rst = []; + const onCancel = () => { + payloadStream.unpipe(message); + payloadStream.destroy(new _errors.RequestError('Canceled.', 'ECANCEL')); + + // set the ignore bit and end the message. + message.ignore = true; + message.end(); + if (request instanceof _request.default && request.paused) { + // resume the request if it was paused so we can read the remaining tokens + request.resume(); + } + }; + request.once('cancel', onCancel); + this.createRequestTimer(); + const message = new _message.default({ + type: packetType, + resetConnection: this.resetConnectionOnNextRequest + }); + this.messageIo.outgoingMessageStream.write(message); + this.transitionTo(this.STATE.SENT_CLIENT_REQUEST); + message.once('finish', () => { + request.removeListener('cancel', onCancel); + request.once('cancel', this._cancelAfterRequestSent); + this.resetConnectionOnNextRequest = false; + this.debug.payload(function () { + return payload.toString(' '); + }); + }); + const payloadStream = _stream.Readable.from(payload); + payloadStream.once('error', error => { + payloadStream.unpipe(message); + + // Only set a request error if no error was set yet. + request.error ??= error; + message.ignore = true; + message.end(); + }); + payloadStream.pipe(message); + } + } + + /** + * Cancel currently executed request. + */ + cancel() { + if (!this.request) { + return false; + } + if (this.request.canceled) { + return false; + } + this.request.cancel(); + return true; + } + + /** + * Reset the connection to its initial state. + * Can be useful for connection pool implementations. + * + * @param callback + */ + reset(callback) { + const request = new _request.default(this.getInitialSql(), err => { + if (this.config.options.tdsVersion < '7_2') { + this.inTransaction = false; + } + callback(err); + }); + this.resetConnectionOnNextRequest = true; + this.execSqlBatch(request); + } + + /** + * @private + */ + currentTransactionDescriptor() { + return this.transactionDescriptors[this.transactionDescriptors.length - 1]; + } + + /** + * @private + */ + getIsolationLevelText(isolationLevel) { + switch (isolationLevel) { + case _transaction.ISOLATION_LEVEL.READ_UNCOMMITTED: + return 'read uncommitted'; + case _transaction.ISOLATION_LEVEL.REPEATABLE_READ: + return 'repeatable read'; + case _transaction.ISOLATION_LEVEL.SERIALIZABLE: + return 'serializable'; + case _transaction.ISOLATION_LEVEL.SNAPSHOT: + return 'snapshot'; + default: + return 'read committed'; + } + } +} +function isTransientError(error) { + if (error instanceof _esAggregateError.default) { + error = error.errors[0]; + } + return error instanceof _errors.ConnectionError && !!error.isTransient; +} +var _default = Connection; +exports.default = _default; +module.exports = Connection; +Connection.prototype.STATE = { + INITIALIZED: { + name: 'Initialized', + events: {} + }, + CONNECTING: { + name: 'Connecting', + enter: function () { + this.initialiseConnection(); + }, + events: { + socketError: function () { + this.transitionTo(this.STATE.FINAL); + }, + connectTimeout: function () { + this.transitionTo(this.STATE.FINAL); + } + } + }, + SENT_PRELOGIN: { + name: 'SentPrelogin', + enter: function () { + (async () => { + let messageBuffer = Buffer.alloc(0); + let message; + try { + message = await this.messageIo.readMessage(); + } catch (err) { + return this.socketError(err); + } + for await (const data of message) { + messageBuffer = Buffer.concat([messageBuffer, data]); + } + const preloginPayload = new _preloginPayload.default(messageBuffer); + this.debug.payload(function () { + return preloginPayload.toString(' '); + }); + if (preloginPayload.fedAuthRequired === 1) { + this.fedAuthRequired = true; + } + if ('strict' !== this.config.options.encrypt && (preloginPayload.encryptionString === 'ON' || preloginPayload.encryptionString === 'REQ')) { + if (!this.config.options.encrypt) { + this.emit('connect', new _errors.ConnectionError("Server requires encryption, set 'encrypt' config option to true.", 'EENCRYPT')); + return this.close(); + } + try { + var _this$routingData; + this.transitionTo(this.STATE.SENT_TLSSSLNEGOTIATION); + await this.messageIo.startTls(this.secureContextOptions, this.config.options.serverName ? this.config.options.serverName : ((_this$routingData = this.routingData) === null || _this$routingData === void 0 ? void 0 : _this$routingData.server) ?? this.config.server, this.config.options.trustServerCertificate); + } catch (err) { + return this.socketError(err); + } + } + this.sendLogin7Packet(); + const { + authentication + } = this.config; + switch (authentication.type) { + case 'azure-active-directory-password': + case 'azure-active-directory-msi-vm': + case 'azure-active-directory-msi-app-service': + case 'azure-active-directory-service-principal-secret': + case 'azure-active-directory-default': + this.transitionTo(this.STATE.SENT_LOGIN7_WITH_FEDAUTH); + break; + case 'ntlm': + this.transitionTo(this.STATE.SENT_LOGIN7_WITH_NTLM); + break; + default: + this.transitionTo(this.STATE.SENT_LOGIN7_WITH_STANDARD_LOGIN); + break; + } + })().catch(err => { + process.nextTick(() => { + throw err; + }); + }); + }, + events: { + socketError: function () { + this.transitionTo(this.STATE.FINAL); + }, + connectTimeout: function () { + this.transitionTo(this.STATE.FINAL); + } + } + }, + REROUTING: { + name: 'ReRouting', + enter: function () { + this.cleanupConnection(CLEANUP_TYPE.REDIRECT); + }, + events: { + message: function () {}, + socketError: function () { + this.transitionTo(this.STATE.FINAL); + }, + connectTimeout: function () { + this.transitionTo(this.STATE.FINAL); + }, + reconnect: function () { + this.transitionTo(this.STATE.CONNECTING); + } + } + }, + TRANSIENT_FAILURE_RETRY: { + name: 'TRANSIENT_FAILURE_RETRY', + enter: function () { + this.curTransientRetryCount++; + this.cleanupConnection(CLEANUP_TYPE.RETRY); + }, + events: { + message: function () {}, + socketError: function () { + this.transitionTo(this.STATE.FINAL); + }, + connectTimeout: function () { + this.transitionTo(this.STATE.FINAL); + }, + retry: function () { + this.createRetryTimer(); + } + } + }, + SENT_TLSSSLNEGOTIATION: { + name: 'SentTLSSSLNegotiation', + events: { + socketError: function () { + this.transitionTo(this.STATE.FINAL); + }, + connectTimeout: function () { + this.transitionTo(this.STATE.FINAL); + } + } + }, + SENT_LOGIN7_WITH_STANDARD_LOGIN: { + name: 'SentLogin7WithStandardLogin', + enter: function () { + (async () => { + let message; + try { + message = await this.messageIo.readMessage(); + } catch (err) { + return this.socketError(err); + } + const handler = new _handler.Login7TokenHandler(this); + const tokenStreamParser = this.createTokenStreamParser(message, handler); + await (0, _events.once)(tokenStreamParser, 'end'); + if (handler.loginAckReceived) { + if (handler.routingData) { + this.routingData = handler.routingData; + this.transitionTo(this.STATE.REROUTING); + } else { + this.transitionTo(this.STATE.LOGGED_IN_SENDING_INITIAL_SQL); + } + } else if (this.loginError) { + if (isTransientError(this.loginError)) { + this.debug.log('Initiating retry on transient error'); + this.transitionTo(this.STATE.TRANSIENT_FAILURE_RETRY); + } else { + this.emit('connect', this.loginError); + this.transitionTo(this.STATE.FINAL); + } + } else { + this.emit('connect', new _errors.ConnectionError('Login failed.', 'ELOGIN')); + this.transitionTo(this.STATE.FINAL); + } + })().catch(err => { + process.nextTick(() => { + throw err; + }); + }); + }, + events: { + socketError: function () { + this.transitionTo(this.STATE.FINAL); + }, + connectTimeout: function () { + this.transitionTo(this.STATE.FINAL); + } + } + }, + SENT_LOGIN7_WITH_NTLM: { + name: 'SentLogin7WithNTLMLogin', + enter: function () { + (async () => { + while (true) { + let message; + try { + message = await this.messageIo.readMessage(); + } catch (err) { + return this.socketError(err); + } + const handler = new _handler.Login7TokenHandler(this); + const tokenStreamParser = this.createTokenStreamParser(message, handler); + await (0, _events.once)(tokenStreamParser, 'end'); + if (handler.loginAckReceived) { + if (handler.routingData) { + this.routingData = handler.routingData; + return this.transitionTo(this.STATE.REROUTING); + } else { + return this.transitionTo(this.STATE.LOGGED_IN_SENDING_INITIAL_SQL); + } + } else if (this.ntlmpacket) { + const authentication = this.config.authentication; + const payload = new _ntlmPayload.default({ + domain: authentication.options.domain, + userName: authentication.options.userName, + password: authentication.options.password, + ntlmpacket: this.ntlmpacket + }); + this.messageIo.sendMessage(_packet.TYPE.NTLMAUTH_PKT, payload.data); + this.debug.payload(function () { + return payload.toString(' '); + }); + this.ntlmpacket = undefined; + } else if (this.loginError) { + if (isTransientError(this.loginError)) { + this.debug.log('Initiating retry on transient error'); + return this.transitionTo(this.STATE.TRANSIENT_FAILURE_RETRY); + } else { + this.emit('connect', this.loginError); + return this.transitionTo(this.STATE.FINAL); + } + } else { + this.emit('connect', new _errors.ConnectionError('Login failed.', 'ELOGIN')); + return this.transitionTo(this.STATE.FINAL); + } + } + })().catch(err => { + process.nextTick(() => { + throw err; + }); + }); + }, + events: { + socketError: function () { + this.transitionTo(this.STATE.FINAL); + }, + connectTimeout: function () { + this.transitionTo(this.STATE.FINAL); + } + } + }, + SENT_LOGIN7_WITH_FEDAUTH: { + name: 'SentLogin7Withfedauth', + enter: function () { + (async () => { + let message; + try { + message = await this.messageIo.readMessage(); + } catch (err) { + return this.socketError(err); + } + const handler = new _handler.Login7TokenHandler(this); + const tokenStreamParser = this.createTokenStreamParser(message, handler); + await (0, _events.once)(tokenStreamParser, 'end'); + if (handler.loginAckReceived) { + if (handler.routingData) { + this.routingData = handler.routingData; + this.transitionTo(this.STATE.REROUTING); + } else { + this.transitionTo(this.STATE.LOGGED_IN_SENDING_INITIAL_SQL); + } + return; + } + const fedAuthInfoToken = handler.fedAuthInfoToken; + if (fedAuthInfoToken && fedAuthInfoToken.stsurl && fedAuthInfoToken.spn) { + const authentication = this.config.authentication; + const tokenScope = new _url.URL('/.default', fedAuthInfoToken.spn).toString(); + let credentials; + switch (authentication.type) { + case 'azure-active-directory-password': + credentials = new _identity.UsernamePasswordCredential(authentication.options.tenantId ?? 'common', authentication.options.clientId, authentication.options.userName, authentication.options.password); + break; + case 'azure-active-directory-msi-vm': + case 'azure-active-directory-msi-app-service': + const msiArgs = authentication.options.clientId ? [authentication.options.clientId, {}] : [{}]; + credentials = new _identity.ManagedIdentityCredential(...msiArgs); + break; + case 'azure-active-directory-default': + const args = authentication.options.clientId ? { + managedIdentityClientId: authentication.options.clientId + } : {}; + credentials = new _identity.DefaultAzureCredential(args); + break; + case 'azure-active-directory-service-principal-secret': + credentials = new _identity.ClientSecretCredential(authentication.options.tenantId, authentication.options.clientId, authentication.options.clientSecret); + break; + } + let tokenResponse; + try { + tokenResponse = await credentials.getToken(tokenScope); + } catch (err) { + this.loginError = new _esAggregateError.default([new _errors.ConnectionError('Security token could not be authenticated or authorized.', 'EFEDAUTH'), err]); + this.emit('connect', this.loginError); + this.transitionTo(this.STATE.FINAL); + return; + } + const token = tokenResponse.token; + this.sendFedAuthTokenMessage(token); + } else if (this.loginError) { + if (isTransientError(this.loginError)) { + this.debug.log('Initiating retry on transient error'); + this.transitionTo(this.STATE.TRANSIENT_FAILURE_RETRY); + } else { + this.emit('connect', this.loginError); + this.transitionTo(this.STATE.FINAL); + } + } else { + this.emit('connect', new _errors.ConnectionError('Login failed.', 'ELOGIN')); + this.transitionTo(this.STATE.FINAL); + } + })().catch(err => { + process.nextTick(() => { + throw err; + }); + }); + }, + events: { + socketError: function () { + this.transitionTo(this.STATE.FINAL); + }, + connectTimeout: function () { + this.transitionTo(this.STATE.FINAL); + } + } + }, + LOGGED_IN_SENDING_INITIAL_SQL: { + name: 'LoggedInSendingInitialSql', + enter: function () { + (async () => { + this.sendInitialSql(); + let message; + try { + message = await this.messageIo.readMessage(); + } catch (err) { + return this.socketError(err); + } + const tokenStreamParser = this.createTokenStreamParser(message, new _handler.InitialSqlTokenHandler(this)); + await (0, _events.once)(tokenStreamParser, 'end'); + this.transitionTo(this.STATE.LOGGED_IN); + this.processedInitialSql(); + })().catch(err => { + process.nextTick(() => { + throw err; + }); + }); + }, + events: { + socketError: function socketError() { + this.transitionTo(this.STATE.FINAL); + }, + connectTimeout: function () { + this.transitionTo(this.STATE.FINAL); + } + } + }, + LOGGED_IN: { + name: 'LoggedIn', + events: { + socketError: function () { + this.transitionTo(this.STATE.FINAL); + } + } + }, + SENT_CLIENT_REQUEST: { + name: 'SentClientRequest', + enter: function () { + (async (_this$request, _this$request3, _this$request10) => { + let message; + try { + message = await this.messageIo.readMessage(); + } catch (err) { + return this.socketError(err); + } + // request timer is stopped on first data package + this.clearRequestTimer(); + const tokenStreamParser = this.createTokenStreamParser(message, new _handler.RequestTokenHandler(this, this.request)); + + // If the request was canceled and we have a `cancelTimer` + // defined, we send a attention message after the + // request message was fully sent off. + // + // We already started consuming the current message + // (but all the token handlers should be no-ops), and + // need to ensure the next message is handled by the + // `SENT_ATTENTION` state. + if ((_this$request = this.request) !== null && _this$request !== void 0 && _this$request.canceled && this.cancelTimer) { + return this.transitionTo(this.STATE.SENT_ATTENTION); + } + const onResume = () => { + tokenStreamParser.resume(); + }; + const onPause = () => { + var _this$request2; + tokenStreamParser.pause(); + (_this$request2 = this.request) === null || _this$request2 === void 0 ? void 0 : _this$request2.once('resume', onResume); + }; + (_this$request3 = this.request) === null || _this$request3 === void 0 ? void 0 : _this$request3.on('pause', onPause); + if (this.request instanceof _request.default && this.request.paused) { + onPause(); + } + const onCancel = () => { + var _this$request4, _this$request5; + tokenStreamParser.removeListener('end', onEndOfMessage); + if (this.request instanceof _request.default && this.request.paused) { + // resume the request if it was paused so we can read the remaining tokens + this.request.resume(); + } + (_this$request4 = this.request) === null || _this$request4 === void 0 ? void 0 : _this$request4.removeListener('pause', onPause); + (_this$request5 = this.request) === null || _this$request5 === void 0 ? void 0 : _this$request5.removeListener('resume', onResume); + + // The `_cancelAfterRequestSent` callback will have sent a + // attention message, so now we need to also switch to + // the `SENT_ATTENTION` state to make sure the attention ack + // message is processed correctly. + this.transitionTo(this.STATE.SENT_ATTENTION); + }; + const onEndOfMessage = () => { + var _this$request6, _this$request7, _this$request8, _this$request9; + (_this$request6 = this.request) === null || _this$request6 === void 0 ? void 0 : _this$request6.removeListener('cancel', this._cancelAfterRequestSent); + (_this$request7 = this.request) === null || _this$request7 === void 0 ? void 0 : _this$request7.removeListener('cancel', onCancel); + (_this$request8 = this.request) === null || _this$request8 === void 0 ? void 0 : _this$request8.removeListener('pause', onPause); + (_this$request9 = this.request) === null || _this$request9 === void 0 ? void 0 : _this$request9.removeListener('resume', onResume); + this.transitionTo(this.STATE.LOGGED_IN); + const sqlRequest = this.request; + this.request = undefined; + if (this.config.options.tdsVersion < '7_2' && sqlRequest.error && this.isSqlBatch) { + this.inTransaction = false; + } + sqlRequest.callback(sqlRequest.error, sqlRequest.rowCount, sqlRequest.rows); + }; + tokenStreamParser.once('end', onEndOfMessage); + (_this$request10 = this.request) === null || _this$request10 === void 0 ? void 0 : _this$request10.once('cancel', onCancel); + })(); + }, + exit: function (nextState) { + this.clearRequestTimer(); + }, + events: { + socketError: function (err) { + const sqlRequest = this.request; + this.request = undefined; + this.transitionTo(this.STATE.FINAL); + sqlRequest.callback(err); + } + } + }, + SENT_ATTENTION: { + name: 'SentAttention', + enter: function () { + (async () => { + let message; + try { + message = await this.messageIo.readMessage(); + } catch (err) { + return this.socketError(err); + } + const handler = new _handler.AttentionTokenHandler(this, this.request); + const tokenStreamParser = this.createTokenStreamParser(message, handler); + await (0, _events.once)(tokenStreamParser, 'end'); + // 3.2.5.7 Sent Attention State + // Discard any data contained in the response, until we receive the attention response + if (handler.attentionReceived) { + this.clearCancelTimer(); + const sqlRequest = this.request; + this.request = undefined; + this.transitionTo(this.STATE.LOGGED_IN); + if (sqlRequest.error && sqlRequest.error instanceof _errors.RequestError && sqlRequest.error.code === 'ETIMEOUT') { + sqlRequest.callback(sqlRequest.error); + } else { + sqlRequest.callback(new _errors.RequestError('Canceled.', 'ECANCEL')); + } + } + })().catch(err => { + process.nextTick(() => { + throw err; + }); + }); + }, + events: { + socketError: function (err) { + const sqlRequest = this.request; + this.request = undefined; + this.transitionTo(this.STATE.FINAL); + sqlRequest.callback(err); + } + } + }, + FINAL: { + name: 'Final', + enter: function () { + this.cleanupConnection(CLEANUP_TYPE.NORMAL); + }, + events: { + connectTimeout: function () { + // Do nothing, as the timer should be cleaned up. + }, + message: function () { + // Do nothing + }, + socketError: function () { + // Do nothing + } + } + } +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_crypto","_interopRequireDefault","require","_os","tls","_interopRequireWildcard","net","_dns","_constants","_stream","_identity","_bulkLoad","_debug","_events","_instanceLookup","_transientErrorLookup","_packet","_preloginPayload","_login7Payload","_ntlmPayload","_request","_rpcrequestPayload","_sqlbatchPayload","_messageIo","_tokenStreamParser","_transaction","_errors","_connector","_library","_tdsVersions","_message","_ntlm","_nodeAbortController","_dataType","_bulkLoadPayload","_specialStoredProcedure","_esAggregateError","_package","_url","_handler","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","KEEP_ALIVE_INITIAL_DELAY","DEFAULT_CONNECT_TIMEOUT","DEFAULT_CLIENT_REQUEST_TIMEOUT","DEFAULT_CANCEL_TIMEOUT","DEFAULT_CONNECT_RETRY_INTERVAL","DEFAULT_PACKET_SIZE","DEFAULT_TEXTSIZE","DEFAULT_DATEFIRST","DEFAULT_PORT","DEFAULT_TDS_VERSION","DEFAULT_LANGUAGE","DEFAULT_DATEFORMAT","CLEANUP_TYPE","NORMAL","REDIRECT","RETRY","Connection","EventEmitter","_cancelAfterRequestSent","constructor","config","TypeError","server","fedAuthRequired","authentication","undefined","type","options","domain","userName","password","toUpperCase","clientId","tenantId","token","clientSecret","abortTransactionOnError","appName","camelCaseColumns","cancelTimeout","columnEncryptionKeyCacheTTL","columnEncryptionSetting","columnNameReplacer","connectionRetryInterval","connectTimeout","connector","connectionIsolationLevel","ISOLATION_LEVEL","READ_COMMITTED","cryptoCredentialsDetails","database","datefirst","dateFormat","debug","data","packet","payload","enableAnsiNull","enableAnsiNullDefault","enableAnsiPadding","enableAnsiWarnings","enableArithAbort","enableConcatNullYieldsNull","enableCursorCloseOnCommit","enableImplicitTransactions","enableNumericRoundabort","enableQuotedIdentifier","encrypt","fallbackToDefaultDb","encryptionKeyStoreProviders","instanceName","isolationLevel","language","localAddress","maxRetriesOnTransientErrors","multiSubnetFailover","packetSize","port","readOnlyIntent","requestTimeout","rowCollectionOnDone","rowCollectionOnRequestCompletion","serverName","serverSupportsColumnEncryption","tdsVersion","textsize","trustedServerNameAE","trustServerCertificate","useColumnNames","useUTC","workstationId","lowerCaseGuids","Error","assertValidIsolationLevel","RangeError","secureContextOptions","secureOptions","create","value","constants","SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS","createDebug","inTransaction","transactionDescriptors","Buffer","from","transactionDepth","isSqlBatch","closed","messageBuffer","alloc","curTransientRetryCount","transientErrorLookup","TransientErrorLookup","state","STATE","INITIALIZED","messageIo","sendMessage","TYPE","ATTENTION","createCancelTimer","connect","connectListener","ConnectionError","name","onConnect","err","removeListener","onError","once","transitionTo","CONNECTING","on","event","listener","emit","args","close","FINAL","initialiseConnection","signal","createConnectTimer","connectOnPort","instanceLookup","timeout","then","process","nextTick","clearConnectTimer","aborted","message","cleanupConnection","cleanupType","clearRequestTimer","clearRetryTimer","closeConnection","request","RequestError","callback","loginError","Debug","createTokenStreamParser","handler","TokenStreamParser","socketHandlingForSendPreLogin","socket","error","socketError","socketClose","socketEnd","setKeepAlive","MessageIO","cleartext","log","sendPreLogin","SENT_PRELOGIN","wrapWithTls","throwIfAborted","Promise","resolve","reject","secureContext","createSecureContext","isIP","encryptOptions","host","ALPNProtocols","servername","encryptsocket","onAbort","destroy","reason","removeEventListener","addEventListener","customConnector","connectOpts","routingData","connectInParallel","connectInSequence","dns","lookup","end","catch","controller","AbortController","connectTimer","setTimeout","abort","clearCancelTimer","cancelTimer","createRequestTimer","requestTimer","createRetryTimer","retryTimer","retryTimeout","hostPostfix","routingMessage","dispatchEvent","cancel","clearTimeout","newState","exit","enter","apply","getEventHandler","eventName","events","SENT_TLSSSLNEGOTIATION","code","REROUTING","TRANSIENT_FAILURE_RETRY","major","minor","build","exec","version","PreloginPayload","Number","subbuild","PRELOGIN","toString","sendLogin7Packet","Login7Payload","versions","clientProgVer","clientPid","pid","connectionId","clientTimeZone","Date","getTimezoneOffset","clientLcid","fedAuth","echo","workflow","fedAuthToken","sspi","createNTLMRequest","hostname","os","libraryName","initDbFatal","LOGIN7","toBuffer","sendFedAuthTokenMessage","accessTokenLen","byteLength","offset","writeUInt32LE","write","FEDAUTH_TOKEN","SENT_LOGIN7_WITH_STANDARD_LOGIN","sendInitialSql","SqlBatchPayload","getInitialSql","currentTransactionDescriptor","Message","SQL_BATCH","outgoingMessageStream","Readable","pipe","push","getIsolationLevelText","join","processedInitialSql","execSqlBatch","makeRequest","sqlTextOrProcedure","execSql","validateParameters","databaseCollation","parameters","TYPES","NVarChar","output","length","precision","scale","makeParamsParameter","RPC_REQUEST","RpcRequestPayload","Procedures","Sp_ExecuteSql","newBulkLoad","table","callbackOrOptions","BulkLoad","execBulkLoad","bulkLoad","rows","executionStarted","streamingMode","firstRowWritten","rowStream","rowToPacketTransform","onCancel","BulkLoadPayload","Request","getBulkInsertSql","BULK_LOAD","prepare","Int","preparing","handle","Sp_Prepare","unprepare","Sp_Unprepare","execute","executeParameters","i","len","parameter","validate","Sp_Execute","callProcedure","beginTransaction","transaction","Transaction","isolationLevelToTSQL","TRANSACTION_MANAGER","beginPayload","commitTransaction","commitPayload","rollbackTransaction","rollbackPayload","saveTransaction","savePayload","cb","useSavepoint","crypto","randomBytes","txDone","done","LOGGED_IN","txErr","packetType","canceled","connection","rowCount","rst","payloadStream","unpipe","ignore","paused","resume","resetConnection","resetConnectionOnNextRequest","SENT_CLIENT_REQUEST","reset","READ_UNCOMMITTED","REPEATABLE_READ","SERIALIZABLE","SNAPSHOT","isTransientError","AggregateError","errors","isTransient","_default","exports","module","readMessage","concat","preloginPayload","encryptionString","_this$routingData","startTls","SENT_LOGIN7_WITH_FEDAUTH","SENT_LOGIN7_WITH_NTLM","reconnect","retry","Login7TokenHandler","tokenStreamParser","loginAckReceived","LOGGED_IN_SENDING_INITIAL_SQL","ntlmpacket","NTLMResponsePayload","NTLMAUTH_PKT","fedAuthInfoToken","stsurl","spn","tokenScope","URL","credentials","UsernamePasswordCredential","msiArgs","ManagedIdentityCredential","managedIdentityClientId","DefaultAzureCredential","ClientSecretCredential","tokenResponse","getToken","InitialSqlTokenHandler","_this$request","_this$request3","_this$request10","RequestTokenHandler","SENT_ATTENTION","onResume","onPause","_this$request2","pause","_this$request4","_this$request5","onEndOfMessage","_this$request6","_this$request7","_this$request8","_this$request9","sqlRequest","nextState","AttentionTokenHandler","attentionReceived"],"sources":["../src/connection.ts"],"sourcesContent":["import crypto from 'crypto';\nimport os from 'os';\nimport * as tls from 'tls';\nimport * as net from 'net';\nimport dns from 'dns';\n\nimport constants from 'constants';\nimport { type SecureContextOptions } from 'tls';\n\nimport { Readable } from 'stream';\n\nimport {\n  DefaultAzureCredential,\n  ClientSecretCredential,\n  ManagedIdentityCredential,\n  UsernamePasswordCredential,\n} from '@azure/identity';\n\nimport BulkLoad, { type Options as BulkLoadOptions, type Callback as BulkLoadCallback } from './bulk-load';\nimport Debug from './debug';\nimport { EventEmitter, once } from 'events';\nimport { instanceLookup } from './instance-lookup';\nimport { TransientErrorLookup } from './transient-error-lookup';\nimport { TYPE } from './packet';\nimport PreloginPayload from './prelogin-payload';\nimport Login7Payload from './login7-payload';\nimport NTLMResponsePayload from './ntlm-payload';\nimport Request from './request';\nimport RpcRequestPayload from './rpcrequest-payload';\nimport SqlBatchPayload from './sqlbatch-payload';\nimport MessageIO from './message-io';\nimport { Parser as TokenStreamParser } from './token/token-stream-parser';\nimport { Transaction, ISOLATION_LEVEL, assertValidIsolationLevel } from './transaction';\nimport { ConnectionError, RequestError } from './errors';\nimport { connectInParallel, connectInSequence } from './connector';\nimport { name as libraryName } from './library';\nimport { versions } from './tds-versions';\nimport Message from './message';\nimport { type Metadata } from './metadata-parser';\nimport { createNTLMRequest } from './ntlm';\nimport { ColumnEncryptionAzureKeyVaultProvider } from './always-encrypted/keystore-provider-azure-key-vault';\n\nimport { AbortController, AbortSignal } from 'node-abort-controller';\nimport { type Parameter, TYPES } from './data-type';\nimport { BulkLoadPayload } from './bulk-load-payload';\nimport { Collation } from './collation';\nimport Procedures from './special-stored-procedure';\n\nimport AggregateError from 'es-aggregate-error';\nimport { version } from '../package.json';\nimport { URL } from 'url';\nimport { AttentionTokenHandler, InitialSqlTokenHandler, Login7TokenHandler, RequestTokenHandler, TokenHandler } from './token/handler';\n\ntype BeginTransactionCallback =\n  /**\n   * The callback is called when the request to start the transaction has completed,\n   * either successfully or with an error.\n   * If an error occurred then `err` will describe the error.\n   *\n   * As only one request at a time may be executed on a connection, another request should not\n   * be initiated until this callback is called.\n   *\n   * @param err If an error occurred, an [[Error]] object with details of the error.\n   * @param transactionDescriptor A Buffer that describe the transaction\n   */\n  (err: Error | null | undefined, transactionDescriptor?: Buffer) => void\n\ntype SaveTransactionCallback =\n  /**\n   * The callback is called when the request to set a savepoint within the\n   * transaction has completed, either successfully or with an error.\n   * If an error occurred then `err` will describe the error.\n   *\n   * As only one request at a time may be executed on a connection, another request should not\n   * be initiated until this callback is called.\n   *\n   * @param err If an error occurred, an [[Error]] object with details of the error.\n   */\n  (err: Error | null | undefined) => void;\n\ntype CommitTransactionCallback =\n  /**\n   * The callback is called when the request to commit the transaction has completed,\n   * either successfully or with an error.\n   * If an error occurred then `err` will describe the error.\n   *\n   * As only one request at a time may be executed on a connection, another request should not\n   * be initiated until this callback is called.\n   *\n   * @param err If an error occurred, an [[Error]] object with details of the error.\n   */\n  (err: Error | null | undefined) => void;\n\ntype RollbackTransactionCallback =\n  /**\n   * The callback is called when the request to rollback the transaction has\n   * completed, either successfully or with an error.\n   * If an error occurred then err will describe the error.\n   *\n   * As only one request at a time may be executed on a connection, another request should not\n   * be initiated until this callback is called.\n   *\n   * @param err If an error occurred, an [[Error]] object with details of the error.\n   */\n  (err: Error | null | undefined) => void;\n\ntype ResetCallback =\n  /**\n   * The callback is called when the connection reset has completed,\n   * either successfully or with an error.\n   *\n   * If an error occurred then `err` will describe the error.\n   *\n   * As only one request at a time may be executed on a connection, another\n   * request should not be initiated until this callback is called\n   *\n   * @param err If an error occurred, an [[Error]] object with details of the error.\n   */\n  (err: Error | null | undefined) => void;\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype TransactionCallback<T extends (err: Error | null | undefined, ...args: any[]) => void> =\n  /**\n   * The callback is called when the request to start a transaction (or create a savepoint, in\n   * the case of a nested transaction) has completed, either successfully or with an error.\n   * If an error occurred, then `err` will describe the error.\n   * If no error occurred, the callback should perform its work and eventually call\n   * `done` with an error or null (to trigger a transaction rollback or a\n   * transaction commit) and an additional completion callback that will be called when the request\n   * to rollback or commit the current transaction has completed, either successfully or with an error.\n   * Additional arguments given to `done` will be passed through to this callback.\n   *\n   * As only one request at a time may be executed on a connection, another request should not\n   * be initiated until the completion callback is called.\n   *\n   * @param err If an error occurred, an [[Error]] object with details of the error.\n   * @param txDone If no error occurred, a function to be called to commit or rollback the transaction.\n   */\n  (err: Error | null | undefined, txDone?: TransactionDone<T>) => void;\n\ntype TransactionDoneCallback = (err: Error | null | undefined, ...args: any[]) => void;\ntype CallbackParameters<T extends (err: Error | null | undefined, ...args: any[]) => any> = T extends (err: Error | null | undefined, ...args: infer P) => any ? P : never;\n\ntype TransactionDone<T extends (err: Error | null | undefined, ...args: any[]) => void> =\n  /**\n   * If no error occurred, a function to be called to commit or rollback the transaction.\n   *\n   * @param err If an err occurred, a string with details of the error.\n   */\n  (err: Error | null | undefined, done: T, ...args: CallbackParameters<T>) => void;\n\n/**\n * @private\n */\nconst KEEP_ALIVE_INITIAL_DELAY = 30 * 1000;\n/**\n * @private\n */\nconst DEFAULT_CONNECT_TIMEOUT = 15 * 1000;\n/**\n * @private\n */\nconst DEFAULT_CLIENT_REQUEST_TIMEOUT = 15 * 1000;\n/**\n * @private\n */\nconst DEFAULT_CANCEL_TIMEOUT = 5 * 1000;\n/**\n * @private\n */\nconst DEFAULT_CONNECT_RETRY_INTERVAL = 500;\n/**\n * @private\n */\nconst DEFAULT_PACKET_SIZE = 4 * 1024;\n/**\n * @private\n */\nconst DEFAULT_TEXTSIZE = 2147483647;\n/**\n * @private\n */\nconst DEFAULT_DATEFIRST = 7;\n/**\n * @private\n */\nconst DEFAULT_PORT = 1433;\n/**\n * @private\n */\nconst DEFAULT_TDS_VERSION = '7_4';\n/**\n * @private\n */\nconst DEFAULT_LANGUAGE = 'us_english';\n/**\n * @private\n */\nconst DEFAULT_DATEFORMAT = 'mdy';\n\ninterface AzureActiveDirectoryMsiAppServiceAuthentication {\n  type: 'azure-active-directory-msi-app-service';\n  options: {\n    /**\n     * If you user want to connect to an Azure app service using a specific client account\n     * they need to provide `clientId` associate to their created identity.\n     *\n     * This is optional for retrieve token from azure web app service\n     */\n    clientId?: string;\n  };\n}\n\ninterface AzureActiveDirectoryMsiVmAuthentication {\n  type: 'azure-active-directory-msi-vm';\n  options: {\n    /**\n     * If you want to connect using a specific client account\n     * they need to provide `clientId` associated to their created identity.\n     *\n     * This is optional for retrieve a token\n     */\n    clientId?: string;\n  };\n}\n\ninterface AzureActiveDirectoryDefaultAuthentication {\n  type: 'azure-active-directory-default';\n  options: {\n    /**\n     * If you want to connect using a specific client account\n     * they need to provide `clientId` associated to their created identity.\n     *\n     * This is optional for retrieving a token\n     */\n    clientId?: string;\n  };\n}\n\n\ninterface AzureActiveDirectoryAccessTokenAuthentication {\n  type: 'azure-active-directory-access-token';\n  options: {\n    /**\n     * A user need to provide `token` which they retrieved else where\n     * to forming the connection.\n     */\n    token: string;\n  };\n}\n\ninterface AzureActiveDirectoryPasswordAuthentication {\n  type: 'azure-active-directory-password';\n  options: {\n    /**\n     * A user need to provide `userName` associate to their account.\n     */\n    userName: string;\n\n    /**\n     * A user need to provide `password` associate to their account.\n     */\n    password: string;\n\n    /**\n     * A client id to use.\n     */\n    clientId: string;\n\n    /**\n     * Optional parameter for specific Azure tenant ID\n     */\n    tenantId: string;\n  };\n}\n\ninterface AzureActiveDirectoryServicePrincipalSecret {\n  type: 'azure-active-directory-service-principal-secret';\n  options: {\n    /**\n     * Application (`client`) ID from your registered Azure application\n     */\n    clientId: string;\n    /**\n     * The created `client secret` for this registered Azure application\n     */\n    clientSecret: string;\n    /**\n     * Directory (`tenant`) ID from your registered Azure application\n     */\n    tenantId: string;\n  };\n}\n\ninterface NtlmAuthentication {\n  type: 'ntlm';\n  options: {\n    /**\n     * User name from your windows account.\n     */\n    userName: string;\n    /**\n     * Password from your windows account.\n     */\n    password: string;\n    /**\n     * Once you set domain for ntlm authentication type, driver will connect to SQL Server using domain login.\n     *\n     * This is necessary for forming a connection using ntlm type\n     */\n    domain: string;\n  };\n}\n\ninterface DefaultAuthentication {\n  type: 'default';\n  options: {\n    /**\n     * User name to use for sql server login.\n     */\n    userName?: string | undefined;\n    /**\n     * Password to use for sql server login.\n     */\n    password?: string | undefined;\n  };\n}\n\ninterface ErrorWithCode extends Error {\n  code?: string;\n}\n\ninterface InternalConnectionConfig {\n  server: string;\n  authentication: DefaultAuthentication | NtlmAuthentication | AzureActiveDirectoryPasswordAuthentication | AzureActiveDirectoryMsiAppServiceAuthentication | AzureActiveDirectoryMsiVmAuthentication | AzureActiveDirectoryAccessTokenAuthentication | AzureActiveDirectoryServicePrincipalSecret | AzureActiveDirectoryDefaultAuthentication;\n  options: InternalConnectionOptions;\n}\n\nexport interface InternalConnectionOptions {\n  abortTransactionOnError: boolean;\n  appName: undefined | string;\n  camelCaseColumns: boolean;\n  cancelTimeout: number;\n  columnEncryptionKeyCacheTTL: number;\n  columnEncryptionSetting: boolean;\n  columnNameReplacer: undefined | ((colName: string, index: number, metadata: Metadata) => string);\n  connectionRetryInterval: number;\n  connector: undefined | (() => Promise<net.Socket>);\n  connectTimeout: number;\n  connectionIsolationLevel: typeof ISOLATION_LEVEL[keyof typeof ISOLATION_LEVEL];\n  cryptoCredentialsDetails: SecureContextOptions;\n  database: undefined | string;\n  datefirst: number;\n  dateFormat: string;\n  debug: {\n    data: boolean;\n    packet: boolean;\n    payload: boolean;\n    token: boolean;\n  };\n  enableAnsiNull: null | boolean;\n  enableAnsiNullDefault: null | boolean;\n  enableAnsiPadding: null | boolean;\n  enableAnsiWarnings: null | boolean;\n  enableArithAbort: null | boolean;\n  enableConcatNullYieldsNull: null | boolean;\n  enableCursorCloseOnCommit: null | boolean;\n  enableImplicitTransactions: null | boolean;\n  enableNumericRoundabort: null | boolean;\n  enableQuotedIdentifier: null | boolean;\n  encrypt: string | boolean;\n  encryptionKeyStoreProviders: KeyStoreProviderMap | undefined;\n  fallbackToDefaultDb: boolean;\n  instanceName: undefined | string;\n  isolationLevel: typeof ISOLATION_LEVEL[keyof typeof ISOLATION_LEVEL];\n  language: string;\n  localAddress: undefined | string;\n  maxRetriesOnTransientErrors: number;\n  multiSubnetFailover: boolean;\n  packetSize: number;\n  port: undefined | number;\n  readOnlyIntent: boolean;\n  requestTimeout: number;\n  rowCollectionOnDone: boolean;\n  rowCollectionOnRequestCompletion: boolean;\n  serverName: undefined | string;\n  serverSupportsColumnEncryption: boolean;\n  tdsVersion: string;\n  textsize: number;\n  trustedServerNameAE: string | undefined;\n  trustServerCertificate: boolean;\n  useColumnNames: boolean;\n  useUTC: boolean;\n  workstationId: undefined | string;\n  lowerCaseGuids: boolean;\n}\n\ninterface KeyStoreProviderMap {\n  [key: string]: ColumnEncryptionAzureKeyVaultProvider;\n}\n\n/**\n * @private\n */\ninterface State {\n  name: string;\n  enter?(this: Connection): void;\n  exit?(this: Connection, newState: State): void;\n  events: {\n    socketError?(this: Connection, err: Error): void;\n    connectTimeout?(this: Connection): void;\n    message?(this: Connection, message: Message): void;\n    retry?(this: Connection): void;\n    reconnect?(this: Connection): void;\n  };\n}\n\ntype Authentication = DefaultAuthentication |\n  NtlmAuthentication |\n  AzureActiveDirectoryPasswordAuthentication |\n  AzureActiveDirectoryMsiAppServiceAuthentication |\n  AzureActiveDirectoryMsiVmAuthentication |\n  AzureActiveDirectoryAccessTokenAuthentication |\n  AzureActiveDirectoryServicePrincipalSecret |\n  AzureActiveDirectoryDefaultAuthentication;\n\ntype AuthenticationType = Authentication['type'];\n\nexport interface ConnectionConfiguration {\n  /**\n   * Hostname to connect to.\n   */\n  server: string;\n  /**\n   * Configuration options for forming the connection.\n   */\n  options?: ConnectionOptions;\n  /**\n   * Authentication related options for connection.\n   */\n  authentication?: AuthenticationOptions;\n}\n\ninterface DebugOptions {\n  /**\n   * A boolean, controlling whether [[debug]] events will be emitted with text describing packet data details\n   *\n   * (default: `false`)\n   */\n  data: boolean;\n  /**\n   * A boolean, controlling whether [[debug]] events will be emitted with text describing packet details\n   *\n   * (default: `false`)\n   */\n  packet: boolean;\n  /**\n   * A boolean, controlling whether [[debug]] events will be emitted with text describing packet payload details\n   *\n   * (default: `false`)\n   */\n  payload: boolean;\n  /**\n   * A boolean, controlling whether [[debug]] events will be emitted with text describing token stream tokens\n   *\n   * (default: `false`)\n   */\n  token: boolean;\n}\n\ninterface AuthenticationOptions {\n  /**\n   * Type of the authentication method, valid types are `default`, `ntlm`,\n   * `azure-active-directory-password`, `azure-active-directory-access-token`,\n   * `azure-active-directory-msi-vm`, `azure-active-directory-msi-app-service`,\n   * `azure-active-directory-default`\n   * or `azure-active-directory-service-principal-secret`\n   */\n  type?: AuthenticationType;\n  /**\n   * Different options for authentication types:\n   *\n   * * `default`: [[DefaultAuthentication.options]]\n   * * `ntlm` :[[NtlmAuthentication]]\n   * * `azure-active-directory-password` : [[AzureActiveDirectoryPasswordAuthentication.options]]\n   * * `azure-active-directory-access-token` : [[AzureActiveDirectoryAccessTokenAuthentication.options]]\n   * * `azure-active-directory-msi-vm` : [[AzureActiveDirectoryMsiVmAuthentication.options]]\n   * * `azure-active-directory-msi-app-service` : [[AzureActiveDirectoryMsiAppServiceAuthentication.options]]\n   * * `azure-active-directory-service-principal-secret` : [[AzureActiveDirectoryServicePrincipalSecret.options]]\n   * * `azure-active-directory-default` : [[AzureActiveDirectoryDefaultAuthentication.options]]\n   */\n  options?: any;\n}\n\nexport interface ConnectionOptions {\n  /**\n   * A boolean determining whether to rollback a transaction automatically if any error is encountered\n   * during the given transaction's execution. This sets the value for `SET XACT_ABORT` during the\n   * initial SQL phase of a connection [documentation](https://docs.microsoft.com/en-us/sql/t-sql/statements/set-xact-abort-transact-sql).\n   */\n  abortTransactionOnError?: boolean;\n\n  /**\n   * Application name used for identifying a specific application in profiling, logging or tracing tools of SQLServer.\n   *\n   * (default: `Tedious`)\n   */\n  appName?: string | undefined;\n\n  /**\n   * A boolean, controlling whether the column names returned will have the first letter converted to lower case\n   * (`true`) or not. This value is ignored if you provide a [[columnNameReplacer]].\n   *\n   * (default: `false`).\n   */\n  camelCaseColumns?: boolean;\n\n  /**\n   * The number of milliseconds before the [[Request.cancel]] (abort) of a request is considered failed\n   *\n   * (default: `5000`).\n   */\n  cancelTimeout?: number;\n\n  /**\n   * A function with parameters `(columnName, index, columnMetaData)` and returning a string. If provided,\n   * this will be called once per column per result-set. The returned value will be used instead of the SQL-provided\n   * column name on row and meta data objects. This allows you to dynamically convert between naming conventions.\n   *\n   * (default: `null`)\n   */\n  columnNameReplacer?: (colName: string, index: number, metadata: Metadata) => string;\n\n  /**\n   * Number of milliseconds before retrying to establish connection, in case of transient failure.\n   *\n   * (default:`500`)\n   */\n  connectionRetryInterval?: number;\n\n  /**\n   * Custom connector factory method.\n   *\n   * (default: `undefined`)\n   */\n  connector?: () => Promise<net.Socket>;\n\n  /**\n   * The number of milliseconds before the attempt to connect is considered failed\n   *\n   * (default: `15000`).\n   */\n  connectTimeout?: number;\n\n  /**\n   * The default isolation level for new connections. All out-of-transaction queries are executed with this setting.\n   *\n   * The isolation levels are available from `require('tedious').ISOLATION_LEVEL`.\n   * * `READ_UNCOMMITTED`\n   * * `READ_COMMITTED`\n   * * `REPEATABLE_READ`\n   * * `SERIALIZABLE`\n   * * `SNAPSHOT`\n   *\n   * (default: `READ_COMMITED`).\n   */\n  connectionIsolationLevel?: number;\n\n  /**\n   * When encryption is used, an object may be supplied that will be used\n   * for the first argument when calling [`tls.createSecurePair`](http://nodejs.org/docs/latest/api/tls.html#tls_tls_createsecurepair_credentials_isserver_requestcert_rejectunauthorized)\n   *\n   * (default: `{}`)\n   */\n  cryptoCredentialsDetails?: SecureContextOptions;\n\n  /**\n   * Database to connect to (default: dependent on server configuration).\n   */\n  database?: string | undefined;\n\n  /**\n   * Sets the first day of the week to a number from 1 through 7.\n   */\n  datefirst?: number;\n\n  /**\n   * A string representing position of month, day and year in temporal datatypes.\n   *\n   * (default: `mdy`)\n   */\n  dateFormat?: string;\n\n  debug?: DebugOptions;\n\n  /**\n   * A boolean, controls the way null values should be used during comparison operation.\n   *\n   * (default: `true`)\n   */\n  enableAnsiNull?: boolean;\n\n  /**\n   * If true, `SET ANSI_NULL_DFLT_ON ON` will be set in the initial sql. This means new columns will be\n   * nullable by default. See the [T-SQL documentation](https://msdn.microsoft.com/en-us/library/ms187375.aspx)\n   *\n   * (default: `true`).\n   */\n  enableAnsiNullDefault?: boolean;\n\n  /**\n   * A boolean, controls if padding should be applied for values shorter than the size of defined column.\n   *\n   * (default: `true`)\n   */\n  enableAnsiPadding?: boolean;\n\n  /**\n   * If true, SQL Server will follow ISO standard behavior during various error conditions. For details,\n   * see [documentation](https://docs.microsoft.com/en-us/sql/t-sql/statements/set-ansi-warnings-transact-sql)\n   *\n   * (default: `true`)\n   */\n  enableAnsiWarnings?: boolean;\n\n  /**\n   * Ends a query when an overflow or divide-by-zero error occurs during query execution.\n   * See [documentation](https://docs.microsoft.com/en-us/sql/t-sql/statements/set-arithabort-transact-sql?view=sql-server-2017)\n   * for more details.\n   *\n   * (default: `true`)\n   */\n  enableArithAbort?: boolean;\n\n  /**\n   * A boolean, determines if concatenation with NULL should result in NULL or empty string value, more details in\n   * [documentation](https://docs.microsoft.com/en-us/sql/t-sql/statements/set-concat-null-yields-null-transact-sql)\n   *\n   * (default: `true`)\n   */\n  enableConcatNullYieldsNull?: boolean;\n\n  /**\n   * A boolean, controls whether cursor should be closed, if the transaction opening it gets committed or rolled\n   * back.\n   *\n   * (default: `null`)\n   */\n  enableCursorCloseOnCommit?: boolean | null;\n\n  /**\n   * A boolean, sets the connection to either implicit or autocommit transaction mode.\n   *\n   * (default: `false`)\n   */\n  enableImplicitTransactions?: boolean;\n\n  /**\n   * If false, error is not generated during loss of precession.\n   *\n   * (default: `false`)\n   */\n  enableNumericRoundabort?: boolean;\n\n  /**\n   * If true, characters enclosed in single quotes are treated as literals and those enclosed double quotes are treated as identifiers.\n   *\n   * (default: `true`)\n   */\n  enableQuotedIdentifier?: boolean;\n\n  /**\n   * A string value that can be only set to 'strict', which indicates the usage TDS 8.0 protocol. Otherwise,\n   * a boolean determining whether or not the connection will be encrypted.\n   *\n   * (default: `true`)\n   */\n  encrypt?: string | boolean;\n\n  /**\n   * By default, if the database requested by [[database]] cannot be accessed,\n   * the connection will fail with an error. However, if [[fallbackToDefaultDb]] is\n   * set to `true`, then the user's default database will be used instead\n   *\n   * (default: `false`)\n   */\n  fallbackToDefaultDb?: boolean;\n\n  /**\n   * The instance name to connect to.\n   * The SQL Server Browser service must be running on the database server,\n   * and UDP port 1434 on the database server must be reachable.\n   *\n   * (no default)\n   *\n   * Mutually exclusive with [[port]].\n   */\n  instanceName?: string | undefined;\n\n  /**\n   * The default isolation level that transactions will be run with.\n   *\n   * The isolation levels are available from `require('tedious').ISOLATION_LEVEL`.\n   * * `READ_UNCOMMITTED`\n   * * `READ_COMMITTED`\n   * * `REPEATABLE_READ`\n   * * `SERIALIZABLE`\n   * * `SNAPSHOT`\n   *\n   * (default: `READ_COMMITED`).\n   */\n  isolationLevel?: number;\n\n  /**\n   * Specifies the language environment for the session. The session language determines the datetime formats and system messages.\n   *\n   * (default: `us_english`).\n   */\n  language?: string;\n\n  /**\n   * A string indicating which network interface (ip address) to use when connecting to SQL Server.\n   */\n  localAddress?: string | undefined;\n\n  /**\n   * A boolean determining whether to parse unique identifier type with lowercase case characters.\n   *\n   * (default: `false`).\n   */\n  lowerCaseGuids?: boolean;\n\n  /**\n   * The maximum number of connection retries for transient errors.、\n   *\n   * (default: `3`).\n   */\n  maxRetriesOnTransientErrors?: number;\n\n  /**\n   * Sets the MultiSubnetFailover = True parameter, which can help minimize the client recovery latency when failovers occur.\n   *\n   * (default: `false`).\n   */\n  multiSubnetFailover?: boolean;\n\n  /**\n   * The size of TDS packets (subject to negotiation with the server).\n   * Should be a power of 2.\n   *\n   * (default: `4096`).\n   */\n  packetSize?: number;\n\n  /**\n   * Port to connect to (default: `1433`).\n   *\n   * Mutually exclusive with [[instanceName]]\n   */\n  port?: number;\n\n  /**\n   * A boolean, determining whether the connection will request read only access from a SQL Server Availability\n   * Group. For more information, see [here](http://msdn.microsoft.com/en-us/library/hh710054.aspx \"Microsoft: Configure Read-Only Routing for an Availability Group (SQL Server)\")\n   *\n   * (default: `false`).\n   */\n  readOnlyIntent?: boolean;\n\n  /**\n   * The number of milliseconds before a request is considered failed, or `0` for no timeout.\n   *\n   * As soon as a response is received, the timeout is cleared. This means that queries that immediately return a response have ability to run longer than this timeout.\n   *\n   * (default: `15000`).\n   */\n  requestTimeout?: number;\n\n  /**\n   * A boolean, that when true will expose received rows in Requests done related events:\n   * * [[Request.Event_doneInProc]]\n   * * [[Request.Event_doneProc]]\n   * * [[Request.Event_done]]\n   *\n   * (default: `false`)\n   *\n   * Caution: If many row are received, enabling this option could result in\n   * excessive memory usage.\n   */\n  rowCollectionOnDone?: boolean;\n\n  /**\n   * A boolean, that when true will expose received rows in Requests' completion callback.See [[Request.constructor]].\n   *\n   * (default: `false`)\n   *\n   * Caution: If many row are received, enabling this option could result in\n   * excessive memory usage.\n   */\n  rowCollectionOnRequestCompletion?: boolean;\n\n  /**\n   * The version of TDS to use. If server doesn't support specified version, negotiated version is used instead.\n   *\n   * The versions are available from `require('tedious').TDS_VERSION`.\n   * * `7_1`\n   * * `7_2`\n   * * `7_3_A`\n   * * `7_3_B`\n   * * `7_4`\n   *\n   * (default: `7_4`)\n   */\n  tdsVersion?: string;\n\n  /**\n   * Specifies the size of varchar(max), nvarchar(max), varbinary(max), text, ntext, and image data returned by a SELECT statement.\n   *\n   * (default: `2147483647`)\n   */\n  textsize?: string;\n\n  /**\n   * If \"true\", the SQL Server SSL certificate is automatically trusted when the communication layer is encrypted using SSL.\n   *\n   * If \"false\", the SQL Server validates the server SSL certificate. If the server certificate validation fails,\n   * the driver raises an error and terminates the connection. Make sure the value passed to serverName exactly\n   * matches the Common Name (CN) or DNS name in the Subject Alternate Name in the server certificate for an SSL connection to succeed.\n   *\n   * (default: `true`)\n   */\n  trustServerCertificate?: boolean;\n\n  /**\n   *\n   */\n  serverName?: string;\n  /**\n   * A boolean determining whether to return rows as arrays or key-value collections.\n   *\n   * (default: `false`).\n   */\n  useColumnNames?: boolean;\n\n  /**\n   * A boolean determining whether to pass time values in UTC or local time.\n   *\n   * (default: `true`).\n   */\n  useUTC?: boolean;\n\n  /**\n   * The workstation ID (WSID) of the client, default os.hostname().\n   * Used for identifying a specific client in profiling, logging or\n   * tracing client activity in SQLServer.\n   *\n   * The value is reported by the TSQL function HOST_NAME().\n   */\n  workstationId?: string | undefined;\n}\n\n/**\n * @private\n */\nconst CLEANUP_TYPE = {\n  NORMAL: 0,\n  REDIRECT: 1,\n  RETRY: 2\n};\n\ninterface RoutingData {\n  server: string;\n  port: number;\n}\n\n/**\n * A [[Connection]] instance represents a single connection to a database server.\n *\n * ```js\n * var Connection = require('tedious').Connection;\n * var config = {\n *  \"authentication\": {\n *    ...,\n *    \"options\": {...}\n *  },\n *  \"options\": {...}\n * };\n * var connection = new Connection(config);\n * ```\n *\n * Only one request at a time may be executed on a connection. Once a [[Request]]\n * has been initiated (with [[Connection.callProcedure]], [[Connection.execSql]],\n * or [[Connection.execSqlBatch]]), another should not be initiated until the\n * [[Request]]'s completion callback is called.\n */\nclass Connection extends EventEmitter {\n  /**\n   * @private\n   */\n  declare fedAuthRequired: boolean;\n  /**\n   * @private\n   */\n  declare config: InternalConnectionConfig;\n  /**\n   * @private\n   */\n  declare secureContextOptions: SecureContextOptions;\n  /**\n   * @private\n   */\n  declare inTransaction: boolean;\n  /**\n   * @private\n   */\n  declare transactionDescriptors: Buffer[];\n  /**\n   * @private\n   */\n  declare transactionDepth: number;\n  /**\n   * @private\n   */\n  declare isSqlBatch: boolean;\n  /**\n   * @private\n   */\n  declare curTransientRetryCount: number;\n  /**\n   * @private\n   */\n  declare transientErrorLookup: TransientErrorLookup;\n  /**\n   * @private\n   */\n  declare closed: boolean;\n  /**\n   * @private\n   */\n  declare loginError: undefined | AggregateError | ConnectionError;\n  /**\n   * @private\n   */\n  declare debug: Debug;\n  /**\n   * @private\n   */\n  declare ntlmpacket: undefined | any;\n  /**\n   * @private\n   */\n  declare ntlmpacketBuffer: undefined | Buffer;\n\n  /**\n   * @private\n   */\n  declare STATE: {\n    INITIALIZED: State;\n    CONNECTING: State;\n    SENT_PRELOGIN: State;\n    REROUTING: State;\n    TRANSIENT_FAILURE_RETRY: State;\n    SENT_TLSSSLNEGOTIATION: State;\n    SENT_LOGIN7_WITH_STANDARD_LOGIN: State;\n    SENT_LOGIN7_WITH_NTLM: State;\n    SENT_LOGIN7_WITH_FEDAUTH: State;\n    LOGGED_IN_SENDING_INITIAL_SQL: State;\n    LOGGED_IN: State;\n    SENT_CLIENT_REQUEST: State;\n    SENT_ATTENTION: State;\n    FINAL: State;\n  };\n\n  /**\n   * @private\n   */\n  declare routingData: undefined | RoutingData;\n\n  /**\n   * @private\n   */\n  declare messageIo: MessageIO;\n  /**\n   * @private\n   */\n  declare state: State;\n  /**\n   * @private\n   */\n  declare resetConnectionOnNextRequest: undefined | boolean;\n\n  /**\n   * @private\n   */\n  declare request: undefined | Request | BulkLoad;\n  /**\n   * @private\n   */\n  declare procReturnStatusValue: undefined | any;\n  /**\n   * @private\n   */\n  declare socket: undefined | net.Socket;\n  /**\n   * @private\n   */\n  declare messageBuffer: Buffer;\n\n  /**\n   * @private\n   */\n  declare connectTimer: undefined | NodeJS.Timeout;\n  /**\n   * @private\n   */\n  declare cancelTimer: undefined | NodeJS.Timeout;\n  /**\n   * @private\n   */\n  declare requestTimer: undefined | NodeJS.Timeout;\n  /**\n   * @private\n   */\n  declare retryTimer: undefined | NodeJS.Timeout;\n\n  /**\n   * @private\n   */\n  _cancelAfterRequestSent: () => void;\n\n  /**\n   * @private\n   */\n  declare databaseCollation: Collation | undefined;\n\n  /**\n   * Note: be aware of the different options field:\n   * 1. config.authentication.options\n   * 2. config.options\n   *\n   * ```js\n   * const { Connection } = require('tedious');\n   *\n   * const config = {\n   *  \"authentication\": {\n   *    ...,\n   *    \"options\": {...}\n   *  },\n   *  \"options\": {...}\n   * };\n   *\n   * const connection = new Connection(config);\n   * ```\n   *\n   * @param config\n   */\n  constructor(config: ConnectionConfiguration) {\n    super();\n\n    if (typeof config !== 'object' || config === null) {\n      throw new TypeError('The \"config\" argument is required and must be of type Object.');\n    }\n\n    if (typeof config.server !== 'string') {\n      throw new TypeError('The \"config.server\" property is required and must be of type string.');\n    }\n\n    this.fedAuthRequired = false;\n\n    let authentication: InternalConnectionConfig['authentication'];\n    if (config.authentication !== undefined) {\n      if (typeof config.authentication !== 'object' || config.authentication === null) {\n        throw new TypeError('The \"config.authentication\" property must be of type Object.');\n      }\n\n      const type = config.authentication.type;\n      const options = config.authentication.options === undefined ? {} : config.authentication.options;\n\n      if (typeof type !== 'string') {\n        throw new TypeError('The \"config.authentication.type\" property must be of type string.');\n      }\n\n      if (type !== 'default' && type !== 'ntlm' && type !== 'azure-active-directory-password' && type !== 'azure-active-directory-access-token' && type !== 'azure-active-directory-msi-vm' && type !== 'azure-active-directory-msi-app-service' && type !== 'azure-active-directory-service-principal-secret' && type !== 'azure-active-directory-default') {\n        throw new TypeError('The \"type\" property must one of \"default\", \"ntlm\", \"azure-active-directory-password\", \"azure-active-directory-access-token\", \"azure-active-directory-default\", \"azure-active-directory-msi-vm\" or \"azure-active-directory-msi-app-service\" or \"azure-active-directory-service-principal-secret\".');\n      }\n\n      if (typeof options !== 'object' || options === null) {\n        throw new TypeError('The \"config.authentication.options\" property must be of type object.');\n      }\n\n      if (type === 'ntlm') {\n        if (typeof options.domain !== 'string') {\n          throw new TypeError('The \"config.authentication.options.domain\" property must be of type string.');\n        }\n\n        if (options.userName !== undefined && typeof options.userName !== 'string') {\n          throw new TypeError('The \"config.authentication.options.userName\" property must be of type string.');\n        }\n\n        if (options.password !== undefined && typeof options.password !== 'string') {\n          throw new TypeError('The \"config.authentication.options.password\" property must be of type string.');\n        }\n\n        authentication = {\n          type: 'ntlm',\n          options: {\n            userName: options.userName,\n            password: options.password,\n            domain: options.domain && options.domain.toUpperCase()\n          }\n        };\n      } else if (type === 'azure-active-directory-password') {\n        if (typeof options.clientId !== 'string') {\n          throw new TypeError('The \"config.authentication.options.clientId\" property must be of type string.');\n        }\n\n        if (options.userName !== undefined && typeof options.userName !== 'string') {\n          throw new TypeError('The \"config.authentication.options.userName\" property must be of type string.');\n        }\n\n        if (options.password !== undefined && typeof options.password !== 'string') {\n          throw new TypeError('The \"config.authentication.options.password\" property must be of type string.');\n        }\n\n        if (options.tenantId !== undefined && typeof options.tenantId !== 'string') {\n          throw new TypeError('The \"config.authentication.options.tenantId\" property must be of type string.');\n        }\n\n        authentication = {\n          type: 'azure-active-directory-password',\n          options: {\n            userName: options.userName,\n            password: options.password,\n            tenantId: options.tenantId,\n            clientId: options.clientId\n          }\n        };\n      } else if (type === 'azure-active-directory-access-token') {\n        if (typeof options.token !== 'string') {\n          throw new TypeError('The \"config.authentication.options.token\" property must be of type string.');\n        }\n\n        authentication = {\n          type: 'azure-active-directory-access-token',\n          options: {\n            token: options.token\n          }\n        };\n      } else if (type === 'azure-active-directory-msi-vm') {\n        if (options.clientId !== undefined && typeof options.clientId !== 'string') {\n          throw new TypeError('The \"config.authentication.options.clientId\" property must be of type string.');\n        }\n\n        authentication = {\n          type: 'azure-active-directory-msi-vm',\n          options: {\n            clientId: options.clientId\n          }\n        };\n      } else if (type === 'azure-active-directory-default') {\n        if (options.clientId !== undefined && typeof options.clientId !== 'string') {\n          throw new TypeError('The \"config.authentication.options.clientId\" property must be of type string.');\n        }\n        authentication = {\n          type: 'azure-active-directory-default',\n          options: {\n            clientId: options.clientId\n          }\n        };\n      } else if (type === 'azure-active-directory-msi-app-service') {\n        if (options.clientId !== undefined && typeof options.clientId !== 'string') {\n          throw new TypeError('The \"config.authentication.options.clientId\" property must be of type string.');\n        }\n\n        authentication = {\n          type: 'azure-active-directory-msi-app-service',\n          options: {\n            clientId: options.clientId\n          }\n        };\n      } else if (type === 'azure-active-directory-service-principal-secret') {\n        if (typeof options.clientId !== 'string') {\n          throw new TypeError('The \"config.authentication.options.clientId\" property must be of type string.');\n        }\n\n        if (typeof options.clientSecret !== 'string') {\n          throw new TypeError('The \"config.authentication.options.clientSecret\" property must be of type string.');\n        }\n\n        if (typeof options.tenantId !== 'string') {\n          throw new TypeError('The \"config.authentication.options.tenantId\" property must be of type string.');\n        }\n\n        authentication = {\n          type: 'azure-active-directory-service-principal-secret',\n          options: {\n            clientId: options.clientId,\n            clientSecret: options.clientSecret,\n            tenantId: options.tenantId\n          }\n        };\n      } else {\n        if (options.userName !== undefined && typeof options.userName !== 'string') {\n          throw new TypeError('The \"config.authentication.options.userName\" property must be of type string.');\n        }\n\n        if (options.password !== undefined && typeof options.password !== 'string') {\n          throw new TypeError('The \"config.authentication.options.password\" property must be of type string.');\n        }\n\n        authentication = {\n          type: 'default',\n          options: {\n            userName: options.userName,\n            password: options.password\n          }\n        };\n      }\n    } else {\n      authentication = {\n        type: 'default',\n        options: {\n          userName: undefined,\n          password: undefined\n        }\n      };\n    }\n\n    this.config = {\n      server: config.server,\n      authentication: authentication,\n      options: {\n        abortTransactionOnError: false,\n        appName: undefined,\n        camelCaseColumns: false,\n        cancelTimeout: DEFAULT_CANCEL_TIMEOUT,\n        columnEncryptionKeyCacheTTL: 2 * 60 * 60 * 1000,  // Units: milliseconds\n        columnEncryptionSetting: false,\n        columnNameReplacer: undefined,\n        connectionRetryInterval: DEFAULT_CONNECT_RETRY_INTERVAL,\n        connectTimeout: DEFAULT_CONNECT_TIMEOUT,\n        connector: undefined,\n        connectionIsolationLevel: ISOLATION_LEVEL.READ_COMMITTED,\n        cryptoCredentialsDetails: {},\n        database: undefined,\n        datefirst: DEFAULT_DATEFIRST,\n        dateFormat: DEFAULT_DATEFORMAT,\n        debug: {\n          data: false,\n          packet: false,\n          payload: false,\n          token: false\n        },\n        enableAnsiNull: true,\n        enableAnsiNullDefault: true,\n        enableAnsiPadding: true,\n        enableAnsiWarnings: true,\n        enableArithAbort: true,\n        enableConcatNullYieldsNull: true,\n        enableCursorCloseOnCommit: null,\n        enableImplicitTransactions: false,\n        enableNumericRoundabort: false,\n        enableQuotedIdentifier: true,\n        encrypt: true,\n        fallbackToDefaultDb: false,\n        encryptionKeyStoreProviders: undefined,\n        instanceName: undefined,\n        isolationLevel: ISOLATION_LEVEL.READ_COMMITTED,\n        language: DEFAULT_LANGUAGE,\n        localAddress: undefined,\n        maxRetriesOnTransientErrors: 3,\n        multiSubnetFailover: false,\n        packetSize: DEFAULT_PACKET_SIZE,\n        port: DEFAULT_PORT,\n        readOnlyIntent: false,\n        requestTimeout: DEFAULT_CLIENT_REQUEST_TIMEOUT,\n        rowCollectionOnDone: false,\n        rowCollectionOnRequestCompletion: false,\n        serverName: undefined,\n        serverSupportsColumnEncryption: false,\n        tdsVersion: DEFAULT_TDS_VERSION,\n        textsize: DEFAULT_TEXTSIZE,\n        trustedServerNameAE: undefined,\n        trustServerCertificate: false,\n        useColumnNames: false,\n        useUTC: true,\n        workstationId: undefined,\n        lowerCaseGuids: false\n      }\n    };\n\n    if (config.options) {\n      if (config.options.port && config.options.instanceName) {\n        throw new Error('Port and instanceName are mutually exclusive, but ' + config.options.port + ' and ' + config.options.instanceName + ' provided');\n      }\n\n      if (config.options.abortTransactionOnError !== undefined) {\n        if (typeof config.options.abortTransactionOnError !== 'boolean' && config.options.abortTransactionOnError !== null) {\n          throw new TypeError('The \"config.options.abortTransactionOnError\" property must be of type string or null.');\n        }\n\n        this.config.options.abortTransactionOnError = config.options.abortTransactionOnError;\n      }\n\n      if (config.options.appName !== undefined) {\n        if (typeof config.options.appName !== 'string') {\n          throw new TypeError('The \"config.options.appName\" property must be of type string.');\n        }\n\n        this.config.options.appName = config.options.appName;\n      }\n\n      if (config.options.camelCaseColumns !== undefined) {\n        if (typeof config.options.camelCaseColumns !== 'boolean') {\n          throw new TypeError('The \"config.options.camelCaseColumns\" property must be of type boolean.');\n        }\n\n        this.config.options.camelCaseColumns = config.options.camelCaseColumns;\n      }\n\n      if (config.options.cancelTimeout !== undefined) {\n        if (typeof config.options.cancelTimeout !== 'number') {\n          throw new TypeError('The \"config.options.cancelTimeout\" property must be of type number.');\n        }\n\n        this.config.options.cancelTimeout = config.options.cancelTimeout;\n      }\n\n      if (config.options.columnNameReplacer) {\n        if (typeof config.options.columnNameReplacer !== 'function') {\n          throw new TypeError('The \"config.options.cancelTimeout\" property must be of type function.');\n        }\n\n        this.config.options.columnNameReplacer = config.options.columnNameReplacer;\n      }\n\n      if (config.options.connectionIsolationLevel !== undefined) {\n        assertValidIsolationLevel(config.options.connectionIsolationLevel, 'config.options.connectionIsolationLevel');\n\n        this.config.options.connectionIsolationLevel = config.options.connectionIsolationLevel;\n      }\n\n      if (config.options.connectTimeout !== undefined) {\n        if (typeof config.options.connectTimeout !== 'number') {\n          throw new TypeError('The \"config.options.connectTimeout\" property must be of type number.');\n        }\n\n        this.config.options.connectTimeout = config.options.connectTimeout;\n      }\n\n      if (config.options.connector !== undefined) {\n        if (typeof config.options.connector !== 'function') {\n          throw new TypeError('The \"config.options.connector\" property must be a function.');\n        }\n\n        this.config.options.connector = config.options.connector;\n      }\n\n      if (config.options.cryptoCredentialsDetails !== undefined) {\n        if (typeof config.options.cryptoCredentialsDetails !== 'object' || config.options.cryptoCredentialsDetails === null) {\n          throw new TypeError('The \"config.options.cryptoCredentialsDetails\" property must be of type Object.');\n        }\n\n        this.config.options.cryptoCredentialsDetails = config.options.cryptoCredentialsDetails;\n      }\n\n      if (config.options.database !== undefined) {\n        if (typeof config.options.database !== 'string') {\n          throw new TypeError('The \"config.options.database\" property must be of type string.');\n        }\n\n        this.config.options.database = config.options.database;\n      }\n\n      if (config.options.datefirst !== undefined) {\n        if (typeof config.options.datefirst !== 'number' && config.options.datefirst !== null) {\n          throw new TypeError('The \"config.options.datefirst\" property must be of type number.');\n        }\n\n        if (config.options.datefirst !== null && (config.options.datefirst < 1 || config.options.datefirst > 7)) {\n          throw new RangeError('The \"config.options.datefirst\" property must be >= 1 and <= 7');\n        }\n\n        this.config.options.datefirst = config.options.datefirst;\n      }\n\n      if (config.options.dateFormat !== undefined) {\n        if (typeof config.options.dateFormat !== 'string' && config.options.dateFormat !== null) {\n          throw new TypeError('The \"config.options.dateFormat\" property must be of type string or null.');\n        }\n\n        this.config.options.dateFormat = config.options.dateFormat;\n      }\n\n      if (config.options.debug) {\n        if (config.options.debug.data !== undefined) {\n          if (typeof config.options.debug.data !== 'boolean') {\n            throw new TypeError('The \"config.options.debug.data\" property must be of type boolean.');\n          }\n\n          this.config.options.debug.data = config.options.debug.data;\n        }\n\n        if (config.options.debug.packet !== undefined) {\n          if (typeof config.options.debug.packet !== 'boolean') {\n            throw new TypeError('The \"config.options.debug.packet\" property must be of type boolean.');\n          }\n\n          this.config.options.debug.packet = config.options.debug.packet;\n        }\n\n        if (config.options.debug.payload !== undefined) {\n          if (typeof config.options.debug.payload !== 'boolean') {\n            throw new TypeError('The \"config.options.debug.payload\" property must be of type boolean.');\n          }\n\n          this.config.options.debug.payload = config.options.debug.payload;\n        }\n\n        if (config.options.debug.token !== undefined) {\n          if (typeof config.options.debug.token !== 'boolean') {\n            throw new TypeError('The \"config.options.debug.token\" property must be of type boolean.');\n          }\n\n          this.config.options.debug.token = config.options.debug.token;\n        }\n      }\n\n      if (config.options.enableAnsiNull !== undefined) {\n        if (typeof config.options.enableAnsiNull !== 'boolean' && config.options.enableAnsiNull !== null) {\n          throw new TypeError('The \"config.options.enableAnsiNull\" property must be of type boolean or null.');\n        }\n\n        this.config.options.enableAnsiNull = config.options.enableAnsiNull;\n      }\n\n      if (config.options.enableAnsiNullDefault !== undefined) {\n        if (typeof config.options.enableAnsiNullDefault !== 'boolean' && config.options.enableAnsiNullDefault !== null) {\n          throw new TypeError('The \"config.options.enableAnsiNullDefault\" property must be of type boolean or null.');\n        }\n\n        this.config.options.enableAnsiNullDefault = config.options.enableAnsiNullDefault;\n      }\n\n      if (config.options.enableAnsiPadding !== undefined) {\n        if (typeof config.options.enableAnsiPadding !== 'boolean' && config.options.enableAnsiPadding !== null) {\n          throw new TypeError('The \"config.options.enableAnsiPadding\" property must be of type boolean or null.');\n        }\n\n        this.config.options.enableAnsiPadding = config.options.enableAnsiPadding;\n      }\n\n      if (config.options.enableAnsiWarnings !== undefined) {\n        if (typeof config.options.enableAnsiWarnings !== 'boolean' && config.options.enableAnsiWarnings !== null) {\n          throw new TypeError('The \"config.options.enableAnsiWarnings\" property must be of type boolean or null.');\n        }\n\n        this.config.options.enableAnsiWarnings = config.options.enableAnsiWarnings;\n      }\n\n      if (config.options.enableArithAbort !== undefined) {\n        if (typeof config.options.enableArithAbort !== 'boolean' && config.options.enableArithAbort !== null) {\n          throw new TypeError('The \"config.options.enableArithAbort\" property must be of type boolean or null.');\n        }\n\n        this.config.options.enableArithAbort = config.options.enableArithAbort;\n      }\n\n      if (config.options.enableConcatNullYieldsNull !== undefined) {\n        if (typeof config.options.enableConcatNullYieldsNull !== 'boolean' && config.options.enableConcatNullYieldsNull !== null) {\n          throw new TypeError('The \"config.options.enableConcatNullYieldsNull\" property must be of type boolean or null.');\n        }\n\n        this.config.options.enableConcatNullYieldsNull = config.options.enableConcatNullYieldsNull;\n      }\n\n      if (config.options.enableCursorCloseOnCommit !== undefined) {\n        if (typeof config.options.enableCursorCloseOnCommit !== 'boolean' && config.options.enableCursorCloseOnCommit !== null) {\n          throw new TypeError('The \"config.options.enableCursorCloseOnCommit\" property must be of type boolean or null.');\n        }\n\n        this.config.options.enableCursorCloseOnCommit = config.options.enableCursorCloseOnCommit;\n      }\n\n      if (config.options.enableImplicitTransactions !== undefined) {\n        if (typeof config.options.enableImplicitTransactions !== 'boolean' && config.options.enableImplicitTransactions !== null) {\n          throw new TypeError('The \"config.options.enableImplicitTransactions\" property must be of type boolean or null.');\n        }\n\n        this.config.options.enableImplicitTransactions = config.options.enableImplicitTransactions;\n      }\n\n      if (config.options.enableNumericRoundabort !== undefined) {\n        if (typeof config.options.enableNumericRoundabort !== 'boolean' && config.options.enableNumericRoundabort !== null) {\n          throw new TypeError('The \"config.options.enableNumericRoundabort\" property must be of type boolean or null.');\n        }\n\n        this.config.options.enableNumericRoundabort = config.options.enableNumericRoundabort;\n      }\n\n      if (config.options.enableQuotedIdentifier !== undefined) {\n        if (typeof config.options.enableQuotedIdentifier !== 'boolean' && config.options.enableQuotedIdentifier !== null) {\n          throw new TypeError('The \"config.options.enableQuotedIdentifier\" property must be of type boolean or null.');\n        }\n\n        this.config.options.enableQuotedIdentifier = config.options.enableQuotedIdentifier;\n      }\n      if (config.options.encrypt !== undefined) {\n        if (typeof config.options.encrypt !== 'boolean') {\n          if (config.options.encrypt !== 'strict') {\n            throw new TypeError('The \"encrypt\" property must be set to \"strict\", or of type boolean.');\n          }\n        }\n\n        this.config.options.encrypt = config.options.encrypt;\n      }\n\n      if (config.options.fallbackToDefaultDb !== undefined) {\n        if (typeof config.options.fallbackToDefaultDb !== 'boolean') {\n          throw new TypeError('The \"config.options.fallbackToDefaultDb\" property must be of type boolean.');\n        }\n\n        this.config.options.fallbackToDefaultDb = config.options.fallbackToDefaultDb;\n      }\n\n      if (config.options.instanceName !== undefined) {\n        if (typeof config.options.instanceName !== 'string') {\n          throw new TypeError('The \"config.options.instanceName\" property must be of type string.');\n        }\n\n        this.config.options.instanceName = config.options.instanceName;\n        this.config.options.port = undefined;\n      }\n\n      if (config.options.isolationLevel !== undefined) {\n        assertValidIsolationLevel(config.options.isolationLevel, 'config.options.isolationLevel');\n\n        this.config.options.isolationLevel = config.options.isolationLevel;\n      }\n\n      if (config.options.language !== undefined) {\n        if (typeof config.options.language !== 'string' && config.options.language !== null) {\n          throw new TypeError('The \"config.options.language\" property must be of type string or null.');\n        }\n\n        this.config.options.language = config.options.language;\n      }\n\n      if (config.options.localAddress !== undefined) {\n        if (typeof config.options.localAddress !== 'string') {\n          throw new TypeError('The \"config.options.localAddress\" property must be of type string.');\n        }\n\n        this.config.options.localAddress = config.options.localAddress;\n      }\n\n      if (config.options.multiSubnetFailover !== undefined) {\n        if (typeof config.options.multiSubnetFailover !== 'boolean') {\n          throw new TypeError('The \"config.options.multiSubnetFailover\" property must be of type boolean.');\n        }\n\n        this.config.options.multiSubnetFailover = config.options.multiSubnetFailover;\n      }\n\n      if (config.options.packetSize !== undefined) {\n        if (typeof config.options.packetSize !== 'number') {\n          throw new TypeError('The \"config.options.packetSize\" property must be of type number.');\n        }\n\n        this.config.options.packetSize = config.options.packetSize;\n      }\n\n      if (config.options.port !== undefined) {\n        if (typeof config.options.port !== 'number') {\n          throw new TypeError('The \"config.options.port\" property must be of type number.');\n        }\n\n        if (config.options.port <= 0 || config.options.port >= 65536) {\n          throw new RangeError('The \"config.options.port\" property must be > 0 and < 65536');\n        }\n\n        this.config.options.port = config.options.port;\n        this.config.options.instanceName = undefined;\n      }\n\n      if (config.options.readOnlyIntent !== undefined) {\n        if (typeof config.options.readOnlyIntent !== 'boolean') {\n          throw new TypeError('The \"config.options.readOnlyIntent\" property must be of type boolean.');\n        }\n\n        this.config.options.readOnlyIntent = config.options.readOnlyIntent;\n      }\n\n      if (config.options.requestTimeout !== undefined) {\n        if (typeof config.options.requestTimeout !== 'number') {\n          throw new TypeError('The \"config.options.requestTimeout\" property must be of type number.');\n        }\n\n        this.config.options.requestTimeout = config.options.requestTimeout;\n      }\n\n      if (config.options.maxRetriesOnTransientErrors !== undefined) {\n        if (typeof config.options.maxRetriesOnTransientErrors !== 'number') {\n          throw new TypeError('The \"config.options.maxRetriesOnTransientErrors\" property must be of type number.');\n        }\n\n        if (config.options.maxRetriesOnTransientErrors < 0) {\n          throw new TypeError('The \"config.options.maxRetriesOnTransientErrors\" property must be equal or greater than 0.');\n        }\n\n        this.config.options.maxRetriesOnTransientErrors = config.options.maxRetriesOnTransientErrors;\n      }\n\n      if (config.options.connectionRetryInterval !== undefined) {\n        if (typeof config.options.connectionRetryInterval !== 'number') {\n          throw new TypeError('The \"config.options.connectionRetryInterval\" property must be of type number.');\n        }\n\n        if (config.options.connectionRetryInterval <= 0) {\n          throw new TypeError('The \"config.options.connectionRetryInterval\" property must be greater than 0.');\n        }\n\n        this.config.options.connectionRetryInterval = config.options.connectionRetryInterval;\n      }\n\n      if (config.options.rowCollectionOnDone !== undefined) {\n        if (typeof config.options.rowCollectionOnDone !== 'boolean') {\n          throw new TypeError('The \"config.options.rowCollectionOnDone\" property must be of type boolean.');\n        }\n\n        this.config.options.rowCollectionOnDone = config.options.rowCollectionOnDone;\n      }\n\n      if (config.options.rowCollectionOnRequestCompletion !== undefined) {\n        if (typeof config.options.rowCollectionOnRequestCompletion !== 'boolean') {\n          throw new TypeError('The \"config.options.rowCollectionOnRequestCompletion\" property must be of type boolean.');\n        }\n\n        this.config.options.rowCollectionOnRequestCompletion = config.options.rowCollectionOnRequestCompletion;\n      }\n\n      if (config.options.tdsVersion !== undefined) {\n        if (typeof config.options.tdsVersion !== 'string') {\n          throw new TypeError('The \"config.options.tdsVersion\" property must be of type string.');\n        }\n\n        this.config.options.tdsVersion = config.options.tdsVersion;\n      }\n\n      if (config.options.textsize !== undefined) {\n        if (typeof config.options.textsize !== 'number' && config.options.textsize !== null) {\n          throw new TypeError('The \"config.options.textsize\" property must be of type number or null.');\n        }\n\n        if (config.options.textsize > 2147483647) {\n          throw new TypeError('The \"config.options.textsize\" can\\'t be greater than 2147483647.');\n        } else if (config.options.textsize < -1) {\n          throw new TypeError('The \"config.options.textsize\" can\\'t be smaller than -1.');\n        }\n\n        this.config.options.textsize = config.options.textsize | 0;\n      }\n\n      if (config.options.trustServerCertificate !== undefined) {\n        if (typeof config.options.trustServerCertificate !== 'boolean') {\n          throw new TypeError('The \"config.options.trustServerCertificate\" property must be of type boolean.');\n        }\n\n        this.config.options.trustServerCertificate = config.options.trustServerCertificate;\n      }\n\n      if (config.options.serverName !== undefined) {\n        if (typeof config.options.serverName !== 'string') {\n          throw new TypeError('The \"config.options.serverName\" property must be of type string.');\n        }\n        this.config.options.serverName = config.options.serverName;\n      }\n\n      if (config.options.useColumnNames !== undefined) {\n        if (typeof config.options.useColumnNames !== 'boolean') {\n          throw new TypeError('The \"config.options.useColumnNames\" property must be of type boolean.');\n        }\n\n        this.config.options.useColumnNames = config.options.useColumnNames;\n      }\n\n      if (config.options.useUTC !== undefined) {\n        if (typeof config.options.useUTC !== 'boolean') {\n          throw new TypeError('The \"config.options.useUTC\" property must be of type boolean.');\n        }\n\n        this.config.options.useUTC = config.options.useUTC;\n      }\n\n      if (config.options.workstationId !== undefined) {\n        if (typeof config.options.workstationId !== 'string') {\n          throw new TypeError('The \"config.options.workstationId\" property must be of type string.');\n        }\n\n        this.config.options.workstationId = config.options.workstationId;\n      }\n\n      if (config.options.lowerCaseGuids !== undefined) {\n        if (typeof config.options.lowerCaseGuids !== 'boolean') {\n          throw new TypeError('The \"config.options.lowerCaseGuids\" property must be of type boolean.');\n        }\n\n        this.config.options.lowerCaseGuids = config.options.lowerCaseGuids;\n      }\n    }\n\n    this.secureContextOptions = this.config.options.cryptoCredentialsDetails;\n    if (this.secureContextOptions.secureOptions === undefined) {\n      // If the caller has not specified their own `secureOptions`,\n      // we set `SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS` here.\n      // Older SQL Server instances running on older Windows versions have\n      // trouble with the BEAST workaround in OpenSSL.\n      // As BEAST is a browser specific exploit, we can just disable this option here.\n      this.secureContextOptions = Object.create(this.secureContextOptions, {\n        secureOptions: {\n          value: constants.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS\n        }\n      });\n    }\n\n    this.debug = this.createDebug();\n    this.inTransaction = false;\n    this.transactionDescriptors = [Buffer.from([0, 0, 0, 0, 0, 0, 0, 0])];\n\n    // 'beginTransaction', 'commitTransaction' and 'rollbackTransaction'\n    // events are utilized to maintain inTransaction property state which in\n    // turn is used in managing transactions. These events are only fired for\n    // TDS version 7.2 and beyond. The properties below are used to emulate\n    // equivalent behavior for TDS versions before 7.2.\n    this.transactionDepth = 0;\n    this.isSqlBatch = false;\n    this.closed = false;\n    this.messageBuffer = Buffer.alloc(0);\n\n    this.curTransientRetryCount = 0;\n    this.transientErrorLookup = new TransientErrorLookup();\n\n    this.state = this.STATE.INITIALIZED;\n\n    this._cancelAfterRequestSent = () => {\n      this.messageIo.sendMessage(TYPE.ATTENTION);\n      this.createCancelTimer();\n    };\n  }\n\n  connect(connectListener?: (err?: Error) => void) {\n    if (this.state !== this.STATE.INITIALIZED) {\n      throw new ConnectionError('`.connect` can not be called on a Connection in `' + this.state.name + '` state.');\n    }\n\n    if (connectListener) {\n      const onConnect = (err?: Error) => {\n        this.removeListener('error', onError);\n        connectListener(err);\n      };\n\n      const onError = (err: Error) => {\n        this.removeListener('connect', onConnect);\n        connectListener(err);\n      };\n\n      this.once('connect', onConnect);\n      this.once('error', onError);\n    }\n\n    this.transitionTo(this.STATE.CONNECTING);\n  }\n\n  /**\n   * The server has reported that the charset has changed.\n   */\n  on(event: 'charsetChange', listener: (charset: string) => void): this\n\n  /**\n   * The attempt to connect and validate has completed.\n   */\n  on(\n    event: 'connect',\n    /**\n     * @param err If successfully connected, will be falsey. If there was a\n     *   problem (with either connecting or validation), will be an [[Error]] object.\n     */\n    listener: (err: Error | undefined) => void\n  ): this\n\n  /**\n   * The server has reported that the active database has changed.\n   * This may be as a result of a successful login, or a `use` statement.\n   */\n  on(event: 'databaseChange', listener: (databaseName: string) => void): this\n\n  /**\n   * A debug message is available. It may be logged or ignored.\n   */\n  on(event: 'debug', listener: (messageText: string) => void): this\n\n  /**\n   * Internal error occurs.\n   */\n  on(event: 'error', listener: (err: Error) => void): this\n\n  /**\n   * The server has issued an error message.\n   */\n  on(event: 'errorMessage', listener: (message: import('./token/token').ErrorMessageToken) => void): this\n\n  /**\n   * The connection has ended.\n   *\n   * This may be as a result of the client calling [[close]], the server\n   * closing the connection, or a network error.\n   */\n  on(event: 'end', listener: () => void): this\n\n  /**\n   * The server has issued an information message.\n   */\n  on(event: 'infoMessage', listener: (message: import('./token/token').InfoMessageToken) => void): this\n\n  /**\n   * The server has reported that the language has changed.\n   */\n  on(event: 'languageChange', listener: (languageName: string) => void): this\n\n  /**\n   * The connection was reset.\n   */\n  on(event: 'resetConnection', listener: () => void): this\n\n  /**\n   * A secure connection has been established.\n   */\n  on(event: 'secure', listener: (cleartext: import('tls').TLSSocket) => void): this\n\n  on(event: string | symbol, listener: (...args: any[]) => void) {\n    return super.on(event, listener);\n  }\n\n  /**\n   * @private\n   */\n  emit(event: 'charsetChange', charset: string): boolean\n  /**\n   * @private\n   */\n  emit(event: 'connect', error?: Error): boolean\n  /**\n   * @private\n   */\n  emit(event: 'databaseChange', databaseName: string): boolean\n  /**\n   * @private\n   */\n  emit(event: 'debug', messageText: string): boolean\n  /**\n   * @private\n   */\n  emit(event: 'error', error: Error): boolean\n  /**\n   * @private\n   */\n  emit(event: 'errorMessage', message: import('./token/token').ErrorMessageToken): boolean\n  /**\n   * @private\n   */\n  emit(event: 'end'): boolean\n  /**\n   * @private\n   */\n  emit(event: 'infoMessage', message: import('./token/token').InfoMessageToken): boolean\n  /**\n   * @private\n   */\n  emit(event: 'languageChange', languageName: string): boolean\n  /**\n   * @private\n   */\n  emit(event: 'secure', cleartext: import('tls').TLSSocket): boolean\n  /**\n   * @private\n   */\n  emit(event: 'rerouting'): boolean\n  /**\n   * @private\n   */\n  emit(event: 'resetConnection'): boolean\n  /**\n   * @private\n   */\n  emit(event: 'retry'): boolean\n  /**\n   * @private\n   */\n  emit(event: 'rollbackTransaction'): boolean\n\n  emit(event: string | symbol, ...args: any[]) {\n    return super.emit(event, ...args);\n  }\n\n  /**\n   * Closes the connection to the database.\n   *\n   * The [[Event_end]] will be emitted once the connection has been closed.\n   */\n  close() {\n    this.transitionTo(this.STATE.FINAL);\n  }\n\n  /**\n   * @private\n   */\n  initialiseConnection() {\n    const signal = this.createConnectTimer();\n\n    if (this.config.options.port) {\n      return this.connectOnPort(this.config.options.port, this.config.options.multiSubnetFailover, signal, this.config.options.connector);\n    } else {\n      return instanceLookup({\n        server: this.config.server,\n        instanceName: this.config.options.instanceName!,\n        timeout: this.config.options.connectTimeout,\n        signal: signal\n      }).then((port) => {\n        process.nextTick(() => {\n          this.connectOnPort(port, this.config.options.multiSubnetFailover, signal, this.config.options.connector);\n        });\n      }, (err) => {\n        this.clearConnectTimer();\n\n        if (signal.aborted) {\n          // Ignore the AbortError for now, this is still handled by the connectTimer firing\n          return;\n        }\n\n        process.nextTick(() => {\n          this.emit('connect', new ConnectionError(err.message, 'EINSTLOOKUP'));\n        });\n      });\n    }\n  }\n\n  /**\n   * @private\n   */\n  cleanupConnection(cleanupType: typeof CLEANUP_TYPE[keyof typeof CLEANUP_TYPE]) {\n    if (!this.closed) {\n      this.clearConnectTimer();\n      this.clearRequestTimer();\n      this.clearRetryTimer();\n      this.closeConnection();\n      if (cleanupType === CLEANUP_TYPE.REDIRECT) {\n        this.emit('rerouting');\n      } else if (cleanupType !== CLEANUP_TYPE.RETRY) {\n        process.nextTick(() => {\n          this.emit('end');\n        });\n      }\n\n      const request = this.request;\n      if (request) {\n        const err = new RequestError('Connection closed before request completed.', 'ECLOSE');\n        request.callback(err);\n        this.request = undefined;\n      }\n\n      this.closed = true;\n      this.loginError = undefined;\n    }\n  }\n\n  /**\n   * @private\n   */\n  createDebug() {\n    const debug = new Debug(this.config.options.debug);\n    debug.on('debug', (message) => {\n      this.emit('debug', message);\n    });\n    return debug;\n  }\n\n  /**\n   * @private\n   */\n  createTokenStreamParser(message: Message, handler: TokenHandler) {\n    return new TokenStreamParser(message, this.debug, handler, this.config.options);\n  }\n\n  socketHandlingForSendPreLogin(socket: net.Socket) {\n    socket.on('error', (error) => { this.socketError(error); });\n    socket.on('close', () => { this.socketClose(); });\n    socket.on('end', () => { this.socketEnd(); });\n    socket.setKeepAlive(true, KEEP_ALIVE_INITIAL_DELAY);\n\n    this.messageIo = new MessageIO(socket, this.config.options.packetSize, this.debug);\n    this.messageIo.on('secure', (cleartext) => { this.emit('secure', cleartext); });\n\n    this.socket = socket;\n\n    this.closed = false;\n    this.debug.log('connected to ' + this.config.server + ':' + this.config.options.port);\n\n    this.sendPreLogin();\n    this.transitionTo(this.STATE.SENT_PRELOGIN);\n  }\n\n  wrapWithTls(socket: net.Socket, signal: AbortSignal): Promise<tls.TLSSocket> {\n    signal.throwIfAborted();\n\n    return new Promise((resolve, reject) => {\n      const secureContext = tls.createSecureContext(this.secureContextOptions);\n      // If connect to an ip address directly,\n      // need to set the servername to an empty string\n      // if the user has not given a servername explicitly\n      const serverName = !net.isIP(this.config.server) ? this.config.server : '';\n      const encryptOptions = {\n        host: this.config.server,\n        socket: socket,\n        ALPNProtocols: ['tds/8.0'],\n        secureContext: secureContext,\n        servername: this.config.options.serverName ? this.config.options.serverName : serverName,\n      };\n\n      const encryptsocket = tls.connect(encryptOptions);\n\n      const onAbort = () => {\n        encryptsocket.removeListener('error', onError);\n        encryptsocket.removeListener('connect', onConnect);\n\n        encryptsocket.destroy();\n\n        reject(signal.reason);\n      };\n\n      const onError = (err: Error) => {\n        signal.removeEventListener('abort', onAbort);\n\n        encryptsocket.removeListener('error', onError);\n        encryptsocket.removeListener('connect', onConnect);\n\n        encryptsocket.destroy();\n\n        reject(err);\n      };\n\n      const onConnect = () => {\n        signal.removeEventListener('abort', onAbort);\n\n        encryptsocket.removeListener('error', onError);\n        encryptsocket.removeListener('connect', onConnect);\n\n        resolve(encryptsocket);\n      };\n\n      signal.addEventListener('abort', onAbort, { once: true });\n\n      encryptsocket.on('error', onError);\n      encryptsocket.on('secureConnect', onConnect);\n    });\n  }\n\n  connectOnPort(port: number, multiSubnetFailover: boolean, signal: AbortSignal, customConnector?: () => Promise<net.Socket>) {\n    const connectOpts = {\n      host: this.routingData ? this.routingData.server : this.config.server,\n      port: this.routingData ? this.routingData.port : port,\n      localAddress: this.config.options.localAddress\n    };\n\n    const connect = customConnector || (multiSubnetFailover ? connectInParallel : connectInSequence);\n\n    (async () => {\n      let socket = await connect(connectOpts, dns.lookup, signal);\n\n      if (this.config.options.encrypt === 'strict') {\n        try {\n          // Wrap the socket with TLS for TDS 8.0\n          socket = await this.wrapWithTls(socket, signal);\n        } catch (err) {\n          socket.end();\n\n          throw err;\n        }\n      }\n\n      this.socketHandlingForSendPreLogin(socket);\n    })().catch((err) => {\n      this.clearConnectTimer();\n\n      if (signal.aborted) {\n        return;\n      }\n\n      process.nextTick(() => { this.socketError(err); });\n    });\n  }\n\n  /**\n   * @private\n   */\n  closeConnection() {\n    if (this.socket) {\n      this.socket.destroy();\n    }\n  }\n\n  /**\n   * @private\n   */\n  createConnectTimer() {\n    const controller = new AbortController();\n    this.connectTimer = setTimeout(() => {\n      controller.abort();\n      this.connectTimeout();\n    }, this.config.options.connectTimeout);\n    return controller.signal;\n  }\n\n  /**\n   * @private\n   */\n  createCancelTimer() {\n    this.clearCancelTimer();\n    const timeout = this.config.options.cancelTimeout;\n    if (timeout > 0) {\n      this.cancelTimer = setTimeout(() => {\n        this.cancelTimeout();\n      }, timeout);\n    }\n  }\n\n  /**\n   * @private\n   */\n  createRequestTimer() {\n    this.clearRequestTimer(); // release old timer, just to be safe\n    const request = this.request as Request;\n    const timeout = (request.timeout !== undefined) ? request.timeout : this.config.options.requestTimeout;\n    if (timeout) {\n      this.requestTimer = setTimeout(() => {\n        this.requestTimeout();\n      }, timeout);\n    }\n  }\n\n  /**\n   * @private\n   */\n  createRetryTimer() {\n    this.clearRetryTimer();\n    this.retryTimer = setTimeout(() => {\n      this.retryTimeout();\n    }, this.config.options.connectionRetryInterval);\n  }\n\n  /**\n   * @private\n   */\n  connectTimeout() {\n    const hostPostfix = this.config.options.port ? `:${this.config.options.port}` : `\\\\${this.config.options.instanceName}`;\n    // If we have routing data stored, this connection has been redirected\n    const server = this.routingData ? this.routingData.server : this.config.server;\n    const port = this.routingData ? `:${this.routingData.port}` : hostPostfix;\n    // Grab the target host from the connection configuration, and from a redirect message\n    // otherwise, leave the message empty.\n    const routingMessage = this.routingData ? ` (redirected from ${this.config.server}${hostPostfix})` : '';\n    const message = `Failed to connect to ${server}${port}${routingMessage} in ${this.config.options.connectTimeout}ms`;\n    this.debug.log(message);\n    this.emit('connect', new ConnectionError(message, 'ETIMEOUT'));\n    this.connectTimer = undefined;\n    this.dispatchEvent('connectTimeout');\n  }\n\n  /**\n   * @private\n   */\n  cancelTimeout() {\n    const message = `Failed to cancel request in ${this.config.options.cancelTimeout}ms`;\n    this.debug.log(message);\n    this.dispatchEvent('socketError', new ConnectionError(message, 'ETIMEOUT'));\n  }\n\n  /**\n   * @private\n   */\n  requestTimeout() {\n    this.requestTimer = undefined;\n    const request = this.request!;\n    request.cancel();\n    const timeout = (request.timeout !== undefined) ? request.timeout : this.config.options.requestTimeout;\n    const message = 'Timeout: Request failed to complete in ' + timeout + 'ms';\n    request.error = new RequestError(message, 'ETIMEOUT');\n  }\n\n  /**\n   * @private\n   */\n  retryTimeout() {\n    this.retryTimer = undefined;\n    this.emit('retry');\n    this.transitionTo(this.STATE.CONNECTING);\n  }\n\n  /**\n   * @private\n   */\n  clearConnectTimer() {\n    if (this.connectTimer) {\n      clearTimeout(this.connectTimer);\n      this.connectTimer = undefined;\n    }\n  }\n\n  /**\n   * @private\n   */\n  clearCancelTimer() {\n    if (this.cancelTimer) {\n      clearTimeout(this.cancelTimer);\n      this.cancelTimer = undefined;\n    }\n  }\n\n  /**\n   * @private\n   */\n  clearRequestTimer() {\n    if (this.requestTimer) {\n      clearTimeout(this.requestTimer);\n      this.requestTimer = undefined;\n    }\n  }\n\n  /**\n   * @private\n   */\n  clearRetryTimer() {\n    if (this.retryTimer) {\n      clearTimeout(this.retryTimer);\n      this.retryTimer = undefined;\n    }\n  }\n\n  /**\n   * @private\n   */\n  transitionTo(newState: State) {\n    if (this.state === newState) {\n      this.debug.log('State is already ' + newState.name);\n      return;\n    }\n\n    if (this.state && this.state.exit) {\n      this.state.exit.call(this, newState);\n    }\n\n    this.debug.log('State change: ' + (this.state ? this.state.name : 'undefined') + ' -> ' + newState.name);\n    this.state = newState;\n\n    if (this.state.enter) {\n      this.state.enter.apply(this);\n    }\n  }\n\n  /**\n   * @private\n   */\n  getEventHandler<T extends keyof State['events']>(eventName: T): NonNullable<State['events'][T]> {\n    const handler = this.state.events[eventName];\n\n    if (!handler) {\n      throw new Error(`No event '${eventName}' in state '${this.state.name}'`);\n    }\n\n    return handler!;\n  }\n\n  /**\n   * @private\n   */\n  dispatchEvent<T extends keyof State['events']>(eventName: T, ...args: Parameters<NonNullable<State['events'][T]>>) {\n    const handler = this.state.events[eventName] as ((this: Connection, ...args: any[]) => void) | undefined;\n    if (handler) {\n      handler.apply(this, args);\n    } else {\n      this.emit('error', new Error(`No event '${eventName}' in state '${this.state.name}'`));\n      this.close();\n    }\n  }\n\n  /**\n   * @private\n   */\n  socketError(error: Error) {\n    if (this.state === this.STATE.CONNECTING || this.state === this.STATE.SENT_TLSSSLNEGOTIATION) {\n      const hostPostfix = this.config.options.port ? `:${this.config.options.port}` : `\\\\${this.config.options.instanceName}`;\n      // If we have routing data stored, this connection has been redirected\n      const server = this.routingData ? this.routingData.server : this.config.server;\n      const port = this.routingData ? `:${this.routingData.port}` : hostPostfix;\n      // Grab the target host from the connection configuration, and from a redirect message\n      // otherwise, leave the message empty.\n      const routingMessage = this.routingData ? ` (redirected from ${this.config.server}${hostPostfix})` : '';\n      const message = `Failed to connect to ${server}${port}${routingMessage} - ${error.message}`;\n      this.debug.log(message);\n      this.emit('connect', new ConnectionError(message, 'ESOCKET'));\n    } else {\n      const message = `Connection lost - ${error.message}`;\n      this.debug.log(message);\n      this.emit('error', new ConnectionError(message, 'ESOCKET'));\n    }\n    this.dispatchEvent('socketError', error);\n  }\n\n  /**\n   * @private\n   */\n  socketEnd() {\n    this.debug.log('socket ended');\n    if (this.state !== this.STATE.FINAL) {\n      const error: ErrorWithCode = new Error('socket hang up');\n      error.code = 'ECONNRESET';\n      this.socketError(error);\n    }\n  }\n\n  /**\n   * @private\n   */\n  socketClose() {\n    this.debug.log('connection to ' + this.config.server + ':' + this.config.options.port + ' closed');\n    if (this.state === this.STATE.REROUTING) {\n      this.debug.log('Rerouting to ' + this.routingData!.server + ':' + this.routingData!.port);\n\n      this.dispatchEvent('reconnect');\n    } else if (this.state === this.STATE.TRANSIENT_FAILURE_RETRY) {\n      const server = this.routingData ? this.routingData.server : this.config.server;\n      const port = this.routingData ? this.routingData.port : this.config.options.port;\n      this.debug.log('Retry after transient failure connecting to ' + server + ':' + port);\n\n      this.dispatchEvent('retry');\n    } else {\n      this.transitionTo(this.STATE.FINAL);\n    }\n  }\n\n  /**\n   * @private\n   */\n  sendPreLogin() {\n    const [, major, minor, build] = /^(\\d+)\\.(\\d+)\\.(\\d+)/.exec(version) ?? ['0.0.0', '0', '0', '0'];\n    const payload = new PreloginPayload({\n      // If encrypt setting is set to 'strict', then we should have already done the encryption before calling\n      // this function. Therefore, the encrypt will be set to false here.\n      // Otherwise, we will set encrypt here based on the encrypt Boolean value from the configuration.\n      encrypt: typeof this.config.options.encrypt === 'boolean' && this.config.options.encrypt,\n      version: { major: Number(major), minor: Number(minor), build: Number(build), subbuild: 0 }\n    });\n\n    this.messageIo.sendMessage(TYPE.PRELOGIN, payload.data);\n    this.debug.payload(function() {\n      return payload.toString('  ');\n    });\n  }\n\n  /**\n   * @private\n   */\n  sendLogin7Packet() {\n    const payload = new Login7Payload({\n      tdsVersion: versions[this.config.options.tdsVersion],\n      packetSize: this.config.options.packetSize,\n      clientProgVer: 0,\n      clientPid: process.pid,\n      connectionId: 0,\n      clientTimeZone: new Date().getTimezoneOffset(),\n      clientLcid: 0x00000409\n    });\n\n    const { authentication } = this.config;\n    switch (authentication.type) {\n      case 'azure-active-directory-password':\n        payload.fedAuth = {\n          type: 'ADAL',\n          echo: this.fedAuthRequired,\n          workflow: 'default'\n        };\n        break;\n\n      case 'azure-active-directory-access-token':\n        payload.fedAuth = {\n          type: 'SECURITYTOKEN',\n          echo: this.fedAuthRequired,\n          fedAuthToken: authentication.options.token\n        };\n        break;\n\n      case 'azure-active-directory-msi-vm':\n      case 'azure-active-directory-default':\n      case 'azure-active-directory-msi-app-service':\n      case 'azure-active-directory-service-principal-secret':\n        payload.fedAuth = {\n          type: 'ADAL',\n          echo: this.fedAuthRequired,\n          workflow: 'integrated'\n        };\n        break;\n\n      case 'ntlm':\n        payload.sspi = createNTLMRequest({ domain: authentication.options.domain });\n        break;\n\n      default:\n        payload.userName = authentication.options.userName;\n        payload.password = authentication.options.password;\n    }\n\n    payload.hostname = this.config.options.workstationId || os.hostname();\n    payload.serverName = this.routingData ? this.routingData.server : this.config.server;\n    payload.appName = this.config.options.appName || 'Tedious';\n    payload.libraryName = libraryName;\n    payload.language = this.config.options.language;\n    payload.database = this.config.options.database;\n    payload.clientId = Buffer.from([1, 2, 3, 4, 5, 6]);\n\n    payload.readOnlyIntent = this.config.options.readOnlyIntent;\n    payload.initDbFatal = !this.config.options.fallbackToDefaultDb;\n\n    this.routingData = undefined;\n    this.messageIo.sendMessage(TYPE.LOGIN7, payload.toBuffer());\n\n    this.debug.payload(function() {\n      return payload.toString('  ');\n    });\n  }\n\n  /**\n   * @private\n   */\n  sendFedAuthTokenMessage(token: string) {\n    const accessTokenLen = Buffer.byteLength(token, 'ucs2');\n    const data = Buffer.alloc(8 + accessTokenLen);\n    let offset = 0;\n    offset = data.writeUInt32LE(accessTokenLen + 4, offset);\n    offset = data.writeUInt32LE(accessTokenLen, offset);\n    data.write(token, offset, 'ucs2');\n    this.messageIo.sendMessage(TYPE.FEDAUTH_TOKEN, data);\n    // sent the fedAuth token message, the rest is similar to standard login 7\n    this.transitionTo(this.STATE.SENT_LOGIN7_WITH_STANDARD_LOGIN);\n  }\n\n  /**\n   * @private\n   */\n  sendInitialSql() {\n    const payload = new SqlBatchPayload(this.getInitialSql(), this.currentTransactionDescriptor(), this.config.options);\n\n    const message = new Message({ type: TYPE.SQL_BATCH });\n    this.messageIo.outgoingMessageStream.write(message);\n    Readable.from(payload).pipe(message);\n  }\n\n  /**\n   * @private\n   */\n  getInitialSql() {\n    const options = [];\n\n    if (this.config.options.enableAnsiNull === true) {\n      options.push('set ansi_nulls on');\n    } else if (this.config.options.enableAnsiNull === false) {\n      options.push('set ansi_nulls off');\n    }\n\n    if (this.config.options.enableAnsiNullDefault === true) {\n      options.push('set ansi_null_dflt_on on');\n    } else if (this.config.options.enableAnsiNullDefault === false) {\n      options.push('set ansi_null_dflt_on off');\n    }\n\n    if (this.config.options.enableAnsiPadding === true) {\n      options.push('set ansi_padding on');\n    } else if (this.config.options.enableAnsiPadding === false) {\n      options.push('set ansi_padding off');\n    }\n\n    if (this.config.options.enableAnsiWarnings === true) {\n      options.push('set ansi_warnings on');\n    } else if (this.config.options.enableAnsiWarnings === false) {\n      options.push('set ansi_warnings off');\n    }\n\n    if (this.config.options.enableArithAbort === true) {\n      options.push('set arithabort on');\n    } else if (this.config.options.enableArithAbort === false) {\n      options.push('set arithabort off');\n    }\n\n    if (this.config.options.enableConcatNullYieldsNull === true) {\n      options.push('set concat_null_yields_null on');\n    } else if (this.config.options.enableConcatNullYieldsNull === false) {\n      options.push('set concat_null_yields_null off');\n    }\n\n    if (this.config.options.enableCursorCloseOnCommit === true) {\n      options.push('set cursor_close_on_commit on');\n    } else if (this.config.options.enableCursorCloseOnCommit === false) {\n      options.push('set cursor_close_on_commit off');\n    }\n\n    if (this.config.options.datefirst !== null) {\n      options.push(`set datefirst ${this.config.options.datefirst}`);\n    }\n\n    if (this.config.options.dateFormat !== null) {\n      options.push(`set dateformat ${this.config.options.dateFormat}`);\n    }\n\n    if (this.config.options.enableImplicitTransactions === true) {\n      options.push('set implicit_transactions on');\n    } else if (this.config.options.enableImplicitTransactions === false) {\n      options.push('set implicit_transactions off');\n    }\n\n    if (this.config.options.language !== null) {\n      options.push(`set language ${this.config.options.language}`);\n    }\n\n    if (this.config.options.enableNumericRoundabort === true) {\n      options.push('set numeric_roundabort on');\n    } else if (this.config.options.enableNumericRoundabort === false) {\n      options.push('set numeric_roundabort off');\n    }\n\n    if (this.config.options.enableQuotedIdentifier === true) {\n      options.push('set quoted_identifier on');\n    } else if (this.config.options.enableQuotedIdentifier === false) {\n      options.push('set quoted_identifier off');\n    }\n\n    if (this.config.options.textsize !== null) {\n      options.push(`set textsize ${this.config.options.textsize}`);\n    }\n\n    if (this.config.options.connectionIsolationLevel !== null) {\n      options.push(`set transaction isolation level ${this.getIsolationLevelText(this.config.options.connectionIsolationLevel)}`);\n    }\n\n    if (this.config.options.abortTransactionOnError === true) {\n      options.push('set xact_abort on');\n    } else if (this.config.options.abortTransactionOnError === false) {\n      options.push('set xact_abort off');\n    }\n\n    return options.join('\\n');\n  }\n\n  /**\n   * @private\n   */\n  processedInitialSql() {\n    this.clearConnectTimer();\n    this.emit('connect');\n  }\n\n  /**\n   * Execute the SQL batch represented by [[Request]].\n   * There is no param support, and unlike [[Request.execSql]],\n   * it is not likely that SQL Server will reuse the execution plan it generates for the SQL.\n   *\n   * In almost all cases, [[Request.execSql]] will be a better choice.\n   *\n   * @param request A [[Request]] object representing the request.\n   */\n  execSqlBatch(request: Request) {\n    this.makeRequest(request, TYPE.SQL_BATCH, new SqlBatchPayload(request.sqlTextOrProcedure!, this.currentTransactionDescriptor(), this.config.options));\n  }\n\n  /**\n   *  Execute the SQL represented by [[Request]].\n   *\n   * As `sp_executesql` is used to execute the SQL, if the same SQL is executed multiples times\n   * using this function, the SQL Server query optimizer is likely to reuse the execution plan it generates\n   * for the first execution. This may also result in SQL server treating the request like a stored procedure\n   * which can result in the [[Event_doneInProc]] or [[Event_doneProc]] events being emitted instead of the\n   * [[Event_done]] event you might expect. Using [[execSqlBatch]] will prevent this from occurring but may have a negative performance impact.\n   *\n   * Beware of the way that scoping rules apply, and how they may [affect local temp tables](http://weblogs.sqlteam.com/mladenp/archive/2006/11/03/17197.aspx)\n   * If you're running in to scoping issues, then [[execSqlBatch]] may be a better choice.\n   * See also [issue #24](https://github.com/pekim/tedious/issues/24)\n   *\n   * @param request A [[Request]] object representing the request.\n   */\n  execSql(request: Request) {\n    try {\n      request.validateParameters(this.databaseCollation);\n    } catch (error: any) {\n      request.error = error;\n\n      process.nextTick(() => {\n        this.debug.log(error.message);\n        request.callback(error);\n      });\n\n      return;\n    }\n\n    const parameters: Parameter[] = [];\n\n    parameters.push({\n      type: TYPES.NVarChar,\n      name: 'statement',\n      value: request.sqlTextOrProcedure,\n      output: false,\n      length: undefined,\n      precision: undefined,\n      scale: undefined\n    });\n\n    if (request.parameters.length) {\n      parameters.push({\n        type: TYPES.NVarChar,\n        name: 'params',\n        value: request.makeParamsParameter(request.parameters),\n        output: false,\n        length: undefined,\n        precision: undefined,\n        scale: undefined\n      });\n\n      parameters.push(...request.parameters);\n    }\n\n    this.makeRequest(request, TYPE.RPC_REQUEST, new RpcRequestPayload(Procedures.Sp_ExecuteSql, parameters, this.currentTransactionDescriptor(), this.config.options, this.databaseCollation));\n  }\n\n  /**\n   * Creates a new BulkLoad instance.\n   *\n   * @param table The name of the table to bulk-insert into.\n   * @param options A set of bulk load options.\n   */\n  newBulkLoad(table: string, callback: BulkLoadCallback): BulkLoad\n  newBulkLoad(table: string, options: BulkLoadOptions, callback: BulkLoadCallback): BulkLoad\n  newBulkLoad(table: string, callbackOrOptions: BulkLoadOptions | BulkLoadCallback, callback?: BulkLoadCallback) {\n    let options: BulkLoadOptions;\n\n    if (callback === undefined) {\n      callback = callbackOrOptions as BulkLoadCallback;\n      options = {};\n    } else {\n      options = callbackOrOptions as BulkLoadOptions;\n    }\n\n    if (typeof options !== 'object') {\n      throw new TypeError('\"options\" argument must be an object');\n    }\n    return new BulkLoad(table, this.databaseCollation, this.config.options, options, callback);\n  }\n\n  /**\n   * Execute a [[BulkLoad]].\n   *\n   * ```js\n   * // We want to perform a bulk load into a table with the following format:\n   * // CREATE TABLE employees (first_name nvarchar(255), last_name nvarchar(255), day_of_birth date);\n   *\n   * const bulkLoad = connection.newBulkLoad('employees', (err, rowCount) => {\n   *   // ...\n   * });\n   *\n   * // First, we need to specify the columns that we want to write to,\n   * // and their definitions. These definitions must match the actual table,\n   * // otherwise the bulk load will fail.\n   * bulkLoad.addColumn('first_name', TYPES.NVarchar, { nullable: false });\n   * bulkLoad.addColumn('last_name', TYPES.NVarchar, { nullable: false });\n   * bulkLoad.addColumn('date_of_birth', TYPES.Date, { nullable: false });\n   *\n   * // Execute a bulk load with a predefined list of rows.\n   * //\n   * // Note that these rows are held in memory until the\n   * // bulk load was performed, so if you need to write a large\n   * // number of rows (e.g. by reading from a CSV file),\n   * // passing an `AsyncIterable` is advisable to keep memory usage low.\n   * connection.execBulkLoad(bulkLoad, [\n   *   { 'first_name': 'Steve', 'last_name': 'Jobs', 'day_of_birth': new Date('02-24-1955') },\n   *   { 'first_name': 'Bill', 'last_name': 'Gates', 'day_of_birth': new Date('10-28-1955') }\n   * ]);\n   * ```\n   *\n   * @param bulkLoad A previously created [[BulkLoad]].\n   * @param rows A [[Iterable]] or [[AsyncIterable]] that contains the rows that should be bulk loaded.\n   */\n  execBulkLoad(bulkLoad: BulkLoad, rows: AsyncIterable<unknown[] | { [columnName: string]: unknown }> | Iterable<unknown[] | { [columnName: string]: unknown }>): void\n\n  execBulkLoad(bulkLoad: BulkLoad, rows?: AsyncIterable<unknown[] | { [columnName: string]: unknown }> | Iterable<unknown[] | { [columnName: string]: unknown }>) {\n    bulkLoad.executionStarted = true;\n\n    if (rows) {\n      if (bulkLoad.streamingMode) {\n        throw new Error(\"Connection.execBulkLoad can't be called with a BulkLoad that was put in streaming mode.\");\n      }\n\n      if (bulkLoad.firstRowWritten) {\n        throw new Error(\"Connection.execBulkLoad can't be called with a BulkLoad that already has rows written to it.\");\n      }\n\n      const rowStream = Readable.from(rows);\n\n      // Destroy the packet transform if an error happens in the row stream,\n      // e.g. if an error is thrown from within a generator or stream.\n      rowStream.on('error', (err) => {\n        bulkLoad.rowToPacketTransform.destroy(err);\n      });\n\n      // Destroy the row stream if an error happens in the packet transform,\n      // e.g. if the bulk load is cancelled.\n      bulkLoad.rowToPacketTransform.on('error', (err) => {\n        rowStream.destroy(err);\n      });\n\n      rowStream.pipe(bulkLoad.rowToPacketTransform);\n    } else if (!bulkLoad.streamingMode) {\n      // If the bulkload was not put into streaming mode by the user,\n      // we end the rowToPacketTransform here for them.\n      //\n      // If it was put into streaming mode, it's the user's responsibility\n      // to end the stream.\n      bulkLoad.rowToPacketTransform.end();\n    }\n\n    const onCancel = () => {\n      request.cancel();\n    };\n\n    const payload = new BulkLoadPayload(bulkLoad);\n\n    const request = new Request(bulkLoad.getBulkInsertSql(), (error: (Error & { code?: string }) | null | undefined) => {\n      bulkLoad.removeListener('cancel', onCancel);\n\n      if (error) {\n        if (error.code === 'UNKNOWN') {\n          error.message += ' This is likely because the schema of the BulkLoad does not match the schema of the table you are attempting to insert into.';\n        }\n        bulkLoad.error = error;\n        bulkLoad.callback(error);\n        return;\n      }\n\n      this.makeRequest(bulkLoad, TYPE.BULK_LOAD, payload);\n    });\n\n    bulkLoad.once('cancel', onCancel);\n\n    this.execSqlBatch(request);\n  }\n\n  /**\n   * Prepare the SQL represented by the request.\n   *\n   * The request can then be used in subsequent calls to\n   * [[execute]] and [[unprepare]]\n   *\n   * @param request A [[Request]] object representing the request.\n   *   Parameters only require a name and type. Parameter values are ignored.\n   */\n  prepare(request: Request) {\n    const parameters: Parameter[] = [];\n\n    parameters.push({\n      type: TYPES.Int,\n      name: 'handle',\n      value: undefined,\n      output: true,\n      length: undefined,\n      precision: undefined,\n      scale: undefined\n    });\n\n    parameters.push({\n      type: TYPES.NVarChar,\n      name: 'params',\n      value: request.parameters.length ? request.makeParamsParameter(request.parameters) : null,\n      output: false,\n      length: undefined,\n      precision: undefined,\n      scale: undefined\n    });\n\n    parameters.push({\n      type: TYPES.NVarChar,\n      name: 'stmt',\n      value: request.sqlTextOrProcedure,\n      output: false,\n      length: undefined,\n      precision: undefined,\n      scale: undefined\n    });\n\n    request.preparing = true;\n\n    // TODO: We need to clean up this event handler, otherwise this leaks memory\n    request.on('returnValue', (name: string, value: any) => {\n      if (name === 'handle') {\n        request.handle = value;\n      } else {\n        request.error = new RequestError(`Tedious > Unexpected output parameter ${name} from sp_prepare`);\n      }\n    });\n\n    this.makeRequest(request, TYPE.RPC_REQUEST, new RpcRequestPayload(Procedures.Sp_Prepare, parameters, this.currentTransactionDescriptor(), this.config.options, this.databaseCollation));\n  }\n\n  /**\n   * Release the SQL Server resources associated with a previously prepared request.\n   *\n   * @param request A [[Request]] object representing the request.\n   *   Parameters only require a name and type.\n   *   Parameter values are ignored.\n   */\n  unprepare(request: Request) {\n    const parameters: Parameter[] = [];\n\n    parameters.push({\n      type: TYPES.Int,\n      name: 'handle',\n      // TODO: Abort if `request.handle` is not set\n      value: request.handle,\n      output: false,\n      length: undefined,\n      precision: undefined,\n      scale: undefined\n    });\n\n    this.makeRequest(request, TYPE.RPC_REQUEST, new RpcRequestPayload(Procedures.Sp_Unprepare, parameters, this.currentTransactionDescriptor(), this.config.options, this.databaseCollation));\n  }\n\n  /**\n   * Execute previously prepared SQL, using the supplied parameters.\n   *\n   * @param request A previously prepared [[Request]].\n   * @param parameters  An object whose names correspond to the names of\n   *   parameters that were added to the [[Request]] before it was prepared.\n   *   The object's values are passed as the parameters' values when the\n   *   request is executed.\n   */\n  execute(request: Request, parameters?: { [key: string]: unknown }) {\n    const executeParameters: Parameter[] = [];\n\n    executeParameters.push({\n      type: TYPES.Int,\n      name: '',\n      // TODO: Abort if `request.handle` is not set\n      value: request.handle,\n      output: false,\n      length: undefined,\n      precision: undefined,\n      scale: undefined\n    });\n\n    try {\n      for (let i = 0, len = request.parameters.length; i < len; i++) {\n        const parameter = request.parameters[i];\n\n        executeParameters.push({\n          ...parameter,\n          value: parameter.type.validate(parameters ? parameters[parameter.name] : null, this.databaseCollation)\n        });\n      }\n    } catch (error: any) {\n      request.error = error;\n\n      process.nextTick(() => {\n        this.debug.log(error.message);\n        request.callback(error);\n      });\n\n      return;\n    }\n\n    this.makeRequest(request, TYPE.RPC_REQUEST, new RpcRequestPayload(Procedures.Sp_Execute, executeParameters, this.currentTransactionDescriptor(), this.config.options, this.databaseCollation));\n  }\n\n  /**\n   * Call a stored procedure represented by [[Request]].\n   *\n   * @param request A [[Request]] object representing the request.\n   */\n  callProcedure(request: Request) {\n    try {\n      request.validateParameters(this.databaseCollation);\n    } catch (error: any) {\n      request.error = error;\n\n      process.nextTick(() => {\n        this.debug.log(error.message);\n        request.callback(error);\n      });\n\n      return;\n    }\n\n    this.makeRequest(request, TYPE.RPC_REQUEST, new RpcRequestPayload(request.sqlTextOrProcedure!, request.parameters, this.currentTransactionDescriptor(), this.config.options, this.databaseCollation));\n  }\n\n  /**\n   * Start a transaction.\n   *\n   * @param callback\n   * @param name A string representing a name to associate with the transaction.\n   *   Optional, and defaults to an empty string. Required when `isolationLevel`\n   *   is present.\n   * @param isolationLevel The isolation level that the transaction is to be run with.\n   *\n   *   The isolation levels are available from `require('tedious').ISOLATION_LEVEL`.\n   *   * `READ_UNCOMMITTED`\n   *   * `READ_COMMITTED`\n   *   * `REPEATABLE_READ`\n   *   * `SERIALIZABLE`\n   *   * `SNAPSHOT`\n   *\n   *   Optional, and defaults to the Connection's isolation level.\n   */\n  beginTransaction(callback: BeginTransactionCallback, name = '', isolationLevel = this.config.options.isolationLevel) {\n    assertValidIsolationLevel(isolationLevel, 'isolationLevel');\n\n    const transaction = new Transaction(name, isolationLevel);\n\n    if (this.config.options.tdsVersion < '7_2') {\n      return this.execSqlBatch(new Request('SET TRANSACTION ISOLATION LEVEL ' + (transaction.isolationLevelToTSQL()) + ';BEGIN TRAN ' + transaction.name, (err) => {\n        this.transactionDepth++;\n        if (this.transactionDepth === 1) {\n          this.inTransaction = true;\n        }\n        callback(err);\n      }));\n    }\n\n    const request = new Request(undefined, (err) => {\n      return callback(err, this.currentTransactionDescriptor());\n    });\n    return this.makeRequest(request, TYPE.TRANSACTION_MANAGER, transaction.beginPayload(this.currentTransactionDescriptor()));\n  }\n\n  /**\n   * Commit a transaction.\n   *\n   * There should be an active transaction - that is, [[beginTransaction]]\n   * should have been previously called.\n   *\n   * @param callback\n   * @param name A string representing a name to associate with the transaction.\n   *   Optional, and defaults to an empty string. Required when `isolationLevel`is present.\n   */\n  commitTransaction(callback: CommitTransactionCallback, name = '') {\n    const transaction = new Transaction(name);\n    if (this.config.options.tdsVersion < '7_2') {\n      return this.execSqlBatch(new Request('COMMIT TRAN ' + transaction.name, (err) => {\n        this.transactionDepth--;\n        if (this.transactionDepth === 0) {\n          this.inTransaction = false;\n        }\n\n        callback(err);\n      }));\n    }\n    const request = new Request(undefined, callback);\n    return this.makeRequest(request, TYPE.TRANSACTION_MANAGER, transaction.commitPayload(this.currentTransactionDescriptor()));\n  }\n\n  /**\n   * Rollback a transaction.\n   *\n   * There should be an active transaction - that is, [[beginTransaction]]\n   * should have been previously called.\n   *\n   * @param callback\n   * @param name A string representing a name to associate with the transaction.\n   *   Optional, and defaults to an empty string.\n   *   Required when `isolationLevel` is present.\n   */\n  rollbackTransaction(callback: RollbackTransactionCallback, name = '') {\n    const transaction = new Transaction(name);\n    if (this.config.options.tdsVersion < '7_2') {\n      return this.execSqlBatch(new Request('ROLLBACK TRAN ' + transaction.name, (err) => {\n        this.transactionDepth--;\n        if (this.transactionDepth === 0) {\n          this.inTransaction = false;\n        }\n        callback(err);\n      }));\n    }\n    const request = new Request(undefined, callback);\n    return this.makeRequest(request, TYPE.TRANSACTION_MANAGER, transaction.rollbackPayload(this.currentTransactionDescriptor()));\n  }\n\n  /**\n   * Set a savepoint within a transaction.\n   *\n   * There should be an active transaction - that is, [[beginTransaction]]\n   * should have been previously called.\n   *\n   * @param callback\n   * @param name A string representing a name to associate with the transaction.\\\n   *   Optional, and defaults to an empty string.\n   *   Required when `isolationLevel` is present.\n   */\n  saveTransaction(callback: SaveTransactionCallback, name: string) {\n    const transaction = new Transaction(name);\n    if (this.config.options.tdsVersion < '7_2') {\n      return this.execSqlBatch(new Request('SAVE TRAN ' + transaction.name, (err) => {\n        this.transactionDepth++;\n        callback(err);\n      }));\n    }\n    const request = new Request(undefined, callback);\n    return this.makeRequest(request, TYPE.TRANSACTION_MANAGER, transaction.savePayload(this.currentTransactionDescriptor()));\n  }\n\n  /**\n   * Run the given callback after starting a transaction, and commit or\n   * rollback the transaction afterwards.\n   *\n   * This is a helper that employs [[beginTransaction]], [[commitTransaction]],\n   * [[rollbackTransaction]], and [[saveTransaction]] to greatly simplify the\n   * use of database transactions and automatically handle transaction nesting.\n   *\n   * @param cb\n   * @param isolationLevel\n   *   The isolation level that the transaction is to be run with.\n   *\n   *   The isolation levels are available from `require('tedious').ISOLATION_LEVEL`.\n   *   * `READ_UNCOMMITTED`\n   *   * `READ_COMMITTED`\n   *   * `REPEATABLE_READ`\n   *   * `SERIALIZABLE`\n   *   * `SNAPSHOT`\n   *\n   *   Optional, and defaults to the Connection's isolation level.\n   */\n  transaction(cb: (err: Error | null | undefined, txDone?: <T extends TransactionDoneCallback>(err: Error | null | undefined, done: T, ...args: CallbackParameters<T>) => void) => void, isolationLevel?: typeof ISOLATION_LEVEL[keyof typeof ISOLATION_LEVEL]) {\n    if (typeof cb !== 'function') {\n      throw new TypeError('`cb` must be a function');\n    }\n\n    const useSavepoint = this.inTransaction;\n    const name = '_tedious_' + (crypto.randomBytes(10).toString('hex'));\n    const txDone: <T extends TransactionDoneCallback>(err: Error | null | undefined, done: T, ...args: CallbackParameters<T>) => void = (err, done, ...args) => {\n      if (err) {\n        if (this.inTransaction && this.state === this.STATE.LOGGED_IN) {\n          this.rollbackTransaction((txErr) => {\n            done(txErr || err, ...args);\n          }, name);\n        } else {\n          done(err, ...args);\n        }\n      } else if (useSavepoint) {\n        if (this.config.options.tdsVersion < '7_2') {\n          this.transactionDepth--;\n        }\n        done(null, ...args);\n      } else {\n        this.commitTransaction((txErr) => {\n          done(txErr, ...args);\n        }, name);\n      }\n    };\n\n    if (useSavepoint) {\n      return this.saveTransaction((err) => {\n        if (err) {\n          return cb(err);\n        }\n\n        if (isolationLevel) {\n          return this.execSqlBatch(new Request('SET transaction isolation level ' + this.getIsolationLevelText(isolationLevel), (err) => {\n            return cb(err, txDone);\n          }));\n        } else {\n          return cb(null, txDone);\n        }\n      }, name);\n    } else {\n      return this.beginTransaction((err) => {\n        if (err) {\n          return cb(err);\n        }\n\n        return cb(null, txDone);\n      }, name, isolationLevel);\n    }\n  }\n\n  /**\n   * @private\n   */\n  makeRequest(request: Request | BulkLoad, packetType: number, payload: (Iterable<Buffer> | AsyncIterable<Buffer>) & { toString: (indent?: string) => string }) {\n    if (this.state !== this.STATE.LOGGED_IN) {\n      const message = 'Requests can only be made in the ' + this.STATE.LOGGED_IN.name + ' state, not the ' + this.state.name + ' state';\n      this.debug.log(message);\n      request.callback(new RequestError(message, 'EINVALIDSTATE'));\n    } else if (request.canceled) {\n      process.nextTick(() => {\n        request.callback(new RequestError('Canceled.', 'ECANCEL'));\n      });\n    } else {\n      if (packetType === TYPE.SQL_BATCH) {\n        this.isSqlBatch = true;\n      } else {\n        this.isSqlBatch = false;\n      }\n\n      this.request = request;\n      request.connection! = this;\n      request.rowCount! = 0;\n      request.rows! = [];\n      request.rst! = [];\n\n      const onCancel = () => {\n        payloadStream.unpipe(message);\n        payloadStream.destroy(new RequestError('Canceled.', 'ECANCEL'));\n\n        // set the ignore bit and end the message.\n        message.ignore = true;\n        message.end();\n\n        if (request instanceof Request && request.paused) {\n          // resume the request if it was paused so we can read the remaining tokens\n          request.resume();\n        }\n      };\n\n      request.once('cancel', onCancel);\n\n      this.createRequestTimer();\n\n      const message = new Message({ type: packetType, resetConnection: this.resetConnectionOnNextRequest });\n      this.messageIo.outgoingMessageStream.write(message);\n      this.transitionTo(this.STATE.SENT_CLIENT_REQUEST);\n\n      message.once('finish', () => {\n        request.removeListener('cancel', onCancel);\n        request.once('cancel', this._cancelAfterRequestSent);\n\n        this.resetConnectionOnNextRequest = false;\n        this.debug.payload(function() {\n          return payload!.toString('  ');\n        });\n      });\n\n      const payloadStream = Readable.from(payload);\n      payloadStream.once('error', (error) => {\n        payloadStream.unpipe(message);\n\n        // Only set a request error if no error was set yet.\n        request.error ??= error;\n\n        message.ignore = true;\n        message.end();\n      });\n      payloadStream.pipe(message);\n    }\n  }\n\n  /**\n   * Cancel currently executed request.\n   */\n  cancel() {\n    if (!this.request) {\n      return false;\n    }\n\n    if (this.request.canceled) {\n      return false;\n    }\n\n    this.request.cancel();\n    return true;\n  }\n\n  /**\n   * Reset the connection to its initial state.\n   * Can be useful for connection pool implementations.\n   *\n   * @param callback\n   */\n  reset(callback: ResetCallback) {\n    const request = new Request(this.getInitialSql(), (err) => {\n      if (this.config.options.tdsVersion < '7_2') {\n        this.inTransaction = false;\n      }\n      callback(err);\n    });\n    this.resetConnectionOnNextRequest = true;\n    this.execSqlBatch(request);\n  }\n\n  /**\n   * @private\n   */\n  currentTransactionDescriptor() {\n    return this.transactionDescriptors[this.transactionDescriptors.length - 1];\n  }\n\n  /**\n   * @private\n   */\n  getIsolationLevelText(isolationLevel: typeof ISOLATION_LEVEL[keyof typeof ISOLATION_LEVEL]) {\n    switch (isolationLevel) {\n      case ISOLATION_LEVEL.READ_UNCOMMITTED:\n        return 'read uncommitted';\n      case ISOLATION_LEVEL.REPEATABLE_READ:\n        return 'repeatable read';\n      case ISOLATION_LEVEL.SERIALIZABLE:\n        return 'serializable';\n      case ISOLATION_LEVEL.SNAPSHOT:\n        return 'snapshot';\n      default:\n        return 'read committed';\n    }\n  }\n}\n\nfunction isTransientError(error: AggregateError | ConnectionError): boolean {\n  if (error instanceof AggregateError) {\n    error = error.errors[0];\n  }\n  return (error instanceof ConnectionError) && !!error.isTransient;\n}\n\nexport default Connection;\nmodule.exports = Connection;\n\nConnection.prototype.STATE = {\n  INITIALIZED: {\n    name: 'Initialized',\n    events: {}\n  },\n  CONNECTING: {\n    name: 'Connecting',\n    enter: function() {\n      this.initialiseConnection();\n    },\n    events: {\n      socketError: function() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      connectTimeout: function() {\n        this.transitionTo(this.STATE.FINAL);\n      }\n    }\n  },\n  SENT_PRELOGIN: {\n    name: 'SentPrelogin',\n    enter: function() {\n      (async () => {\n        let messageBuffer = Buffer.alloc(0);\n\n        let message;\n        try {\n          message = await this.messageIo.readMessage();\n        } catch (err: any) {\n          return this.socketError(err);\n        }\n\n        for await (const data of message) {\n          messageBuffer = Buffer.concat([messageBuffer, data]);\n        }\n\n        const preloginPayload = new PreloginPayload(messageBuffer);\n        this.debug.payload(function() {\n          return preloginPayload.toString('  ');\n        });\n\n        if (preloginPayload.fedAuthRequired === 1) {\n          this.fedAuthRequired = true;\n        }\n        if ('strict' !== this.config.options.encrypt && (preloginPayload.encryptionString === 'ON' || preloginPayload.encryptionString === 'REQ')) {\n          if (!this.config.options.encrypt) {\n            this.emit('connect', new ConnectionError(\"Server requires encryption, set 'encrypt' config option to true.\", 'EENCRYPT'));\n            return this.close();\n          }\n\n          try {\n            this.transitionTo(this.STATE.SENT_TLSSSLNEGOTIATION);\n            await this.messageIo.startTls(this.secureContextOptions, this.config.options.serverName ? this.config.options.serverName : this.routingData?.server ?? this.config.server, this.config.options.trustServerCertificate);\n          } catch (err: any) {\n            return this.socketError(err);\n          }\n        }\n\n        this.sendLogin7Packet();\n\n        const { authentication } = this.config;\n\n        switch (authentication.type) {\n          case 'azure-active-directory-password':\n          case 'azure-active-directory-msi-vm':\n          case 'azure-active-directory-msi-app-service':\n          case 'azure-active-directory-service-principal-secret':\n          case 'azure-active-directory-default':\n            this.transitionTo(this.STATE.SENT_LOGIN7_WITH_FEDAUTH);\n            break;\n          case 'ntlm':\n            this.transitionTo(this.STATE.SENT_LOGIN7_WITH_NTLM);\n            break;\n          default:\n            this.transitionTo(this.STATE.SENT_LOGIN7_WITH_STANDARD_LOGIN);\n            break;\n        }\n      })().catch((err) => {\n        process.nextTick(() => {\n          throw err;\n        });\n      });\n    },\n    events: {\n      socketError: function() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      connectTimeout: function() {\n        this.transitionTo(this.STATE.FINAL);\n      }\n    }\n  },\n  REROUTING: {\n    name: 'ReRouting',\n    enter: function() {\n      this.cleanupConnection(CLEANUP_TYPE.REDIRECT);\n    },\n    events: {\n      message: function() {\n      },\n      socketError: function() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      connectTimeout: function() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      reconnect: function() {\n        this.transitionTo(this.STATE.CONNECTING);\n      }\n    }\n  },\n  TRANSIENT_FAILURE_RETRY: {\n    name: 'TRANSIENT_FAILURE_RETRY',\n    enter: function() {\n      this.curTransientRetryCount++;\n      this.cleanupConnection(CLEANUP_TYPE.RETRY);\n    },\n    events: {\n      message: function() {\n      },\n      socketError: function() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      connectTimeout: function() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      retry: function() {\n        this.createRetryTimer();\n      }\n    }\n  },\n  SENT_TLSSSLNEGOTIATION: {\n    name: 'SentTLSSSLNegotiation',\n    events: {\n      socketError: function() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      connectTimeout: function() {\n        this.transitionTo(this.STATE.FINAL);\n      }\n    }\n  },\n  SENT_LOGIN7_WITH_STANDARD_LOGIN: {\n    name: 'SentLogin7WithStandardLogin',\n    enter: function() {\n      (async () => {\n        let message;\n        try {\n          message = await this.messageIo.readMessage();\n        } catch (err: any) {\n          return this.socketError(err);\n        }\n\n        const handler = new Login7TokenHandler(this);\n        const tokenStreamParser = this.createTokenStreamParser(message, handler);\n\n        await once(tokenStreamParser, 'end');\n\n        if (handler.loginAckReceived) {\n          if (handler.routingData) {\n            this.routingData = handler.routingData;\n            this.transitionTo(this.STATE.REROUTING);\n          } else {\n            this.transitionTo(this.STATE.LOGGED_IN_SENDING_INITIAL_SQL);\n          }\n        } else if (this.loginError) {\n          if (isTransientError(this.loginError)) {\n            this.debug.log('Initiating retry on transient error');\n            this.transitionTo(this.STATE.TRANSIENT_FAILURE_RETRY);\n          } else {\n            this.emit('connect', this.loginError);\n            this.transitionTo(this.STATE.FINAL);\n          }\n        } else {\n          this.emit('connect', new ConnectionError('Login failed.', 'ELOGIN'));\n          this.transitionTo(this.STATE.FINAL);\n        }\n      })().catch((err) => {\n        process.nextTick(() => {\n          throw err;\n        });\n      });\n    },\n    events: {\n      socketError: function() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      connectTimeout: function() {\n        this.transitionTo(this.STATE.FINAL);\n      }\n    }\n  },\n  SENT_LOGIN7_WITH_NTLM: {\n    name: 'SentLogin7WithNTLMLogin',\n    enter: function() {\n      (async () => {\n        while (true) {\n          let message;\n          try {\n            message = await this.messageIo.readMessage();\n          } catch (err: any) {\n            return this.socketError(err);\n          }\n\n          const handler = new Login7TokenHandler(this);\n          const tokenStreamParser = this.createTokenStreamParser(message, handler);\n\n          await once(tokenStreamParser, 'end');\n\n          if (handler.loginAckReceived) {\n            if (handler.routingData) {\n              this.routingData = handler.routingData;\n              return this.transitionTo(this.STATE.REROUTING);\n            } else {\n              return this.transitionTo(this.STATE.LOGGED_IN_SENDING_INITIAL_SQL);\n            }\n          } else if (this.ntlmpacket) {\n            const authentication = this.config.authentication as NtlmAuthentication;\n\n            const payload = new NTLMResponsePayload({\n              domain: authentication.options.domain,\n              userName: authentication.options.userName,\n              password: authentication.options.password,\n              ntlmpacket: this.ntlmpacket\n            });\n\n            this.messageIo.sendMessage(TYPE.NTLMAUTH_PKT, payload.data);\n            this.debug.payload(function() {\n              return payload.toString('  ');\n            });\n\n            this.ntlmpacket = undefined;\n          } else if (this.loginError) {\n            if (isTransientError(this.loginError)) {\n              this.debug.log('Initiating retry on transient error');\n              return this.transitionTo(this.STATE.TRANSIENT_FAILURE_RETRY);\n            } else {\n              this.emit('connect', this.loginError);\n              return this.transitionTo(this.STATE.FINAL);\n            }\n          } else {\n            this.emit('connect', new ConnectionError('Login failed.', 'ELOGIN'));\n            return this.transitionTo(this.STATE.FINAL);\n          }\n        }\n\n      })().catch((err) => {\n        process.nextTick(() => {\n          throw err;\n        });\n      });\n    },\n    events: {\n      socketError: function() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      connectTimeout: function() {\n        this.transitionTo(this.STATE.FINAL);\n      }\n    }\n  },\n  SENT_LOGIN7_WITH_FEDAUTH: {\n    name: 'SentLogin7Withfedauth',\n    enter: function() {\n      (async () => {\n        let message;\n        try {\n          message = await this.messageIo.readMessage();\n        } catch (err: any) {\n          return this.socketError(err);\n        }\n\n        const handler = new Login7TokenHandler(this);\n        const tokenStreamParser = this.createTokenStreamParser(message, handler);\n        await once(tokenStreamParser, 'end');\n        if (handler.loginAckReceived) {\n          if (handler.routingData) {\n            this.routingData = handler.routingData;\n            this.transitionTo(this.STATE.REROUTING);\n          } else {\n            this.transitionTo(this.STATE.LOGGED_IN_SENDING_INITIAL_SQL);\n          }\n\n          return;\n        }\n\n        const fedAuthInfoToken = handler.fedAuthInfoToken;\n\n        if (fedAuthInfoToken && fedAuthInfoToken.stsurl && fedAuthInfoToken.spn) {\n          const authentication = this.config.authentication as AzureActiveDirectoryPasswordAuthentication | AzureActiveDirectoryMsiVmAuthentication | AzureActiveDirectoryMsiAppServiceAuthentication | AzureActiveDirectoryServicePrincipalSecret | AzureActiveDirectoryDefaultAuthentication;\n          const tokenScope = new URL('/.default', fedAuthInfoToken.spn).toString();\n\n          let credentials;\n\n          switch (authentication.type) {\n            case 'azure-active-directory-password':\n              credentials = new UsernamePasswordCredential(\n                authentication.options.tenantId ?? 'common',\n                authentication.options.clientId,\n                authentication.options.userName,\n                authentication.options.password\n              );\n              break;\n            case 'azure-active-directory-msi-vm':\n            case 'azure-active-directory-msi-app-service':\n              const msiArgs = authentication.options.clientId ? [authentication.options.clientId, {}] : [{}];\n              credentials = new ManagedIdentityCredential(...msiArgs);\n              break;\n            case 'azure-active-directory-default':\n              const args = authentication.options.clientId ? { managedIdentityClientId: authentication.options.clientId } : {};\n              credentials = new DefaultAzureCredential(args);\n              break;\n            case 'azure-active-directory-service-principal-secret':\n              credentials = new ClientSecretCredential(\n                authentication.options.tenantId,\n                authentication.options.clientId,\n                authentication.options.clientSecret\n              );\n              break;\n          }\n\n          let tokenResponse;\n          try {\n            tokenResponse = await credentials.getToken(tokenScope);\n          } catch (err) {\n            this.loginError = new AggregateError(\n              [new ConnectionError('Security token could not be authenticated or authorized.', 'EFEDAUTH'), err]);\n            this.emit('connect', this.loginError);\n            this.transitionTo(this.STATE.FINAL);\n            return;\n          }\n\n\n          const token = tokenResponse.token;\n          this.sendFedAuthTokenMessage(token);\n\n        } else if (this.loginError) {\n          if (isTransientError(this.loginError)) {\n            this.debug.log('Initiating retry on transient error');\n            this.transitionTo(this.STATE.TRANSIENT_FAILURE_RETRY);\n          } else {\n            this.emit('connect', this.loginError);\n            this.transitionTo(this.STATE.FINAL);\n          }\n        } else {\n          this.emit('connect', new ConnectionError('Login failed.', 'ELOGIN'));\n          this.transitionTo(this.STATE.FINAL);\n        }\n\n      })().catch((err) => {\n        process.nextTick(() => {\n          throw err;\n        });\n      });\n    },\n    events: {\n      socketError: function() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      connectTimeout: function() {\n        this.transitionTo(this.STATE.FINAL);\n      }\n    }\n  },\n  LOGGED_IN_SENDING_INITIAL_SQL: {\n    name: 'LoggedInSendingInitialSql',\n    enter: function() {\n      (async () => {\n        this.sendInitialSql();\n        let message;\n        try {\n          message = await this.messageIo.readMessage();\n        } catch (err: any) {\n          return this.socketError(err);\n        }\n        const tokenStreamParser = this.createTokenStreamParser(message, new InitialSqlTokenHandler(this));\n        await once(tokenStreamParser, 'end');\n\n        this.transitionTo(this.STATE.LOGGED_IN);\n        this.processedInitialSql();\n\n      })().catch((err) => {\n        process.nextTick(() => {\n          throw err;\n        });\n      });\n    },\n    events: {\n      socketError: function socketError() {\n        this.transitionTo(this.STATE.FINAL);\n      },\n      connectTimeout: function() {\n        this.transitionTo(this.STATE.FINAL);\n      }\n    }\n  },\n  LOGGED_IN: {\n    name: 'LoggedIn',\n    events: {\n      socketError: function() {\n        this.transitionTo(this.STATE.FINAL);\n      }\n    }\n  },\n  SENT_CLIENT_REQUEST: {\n    name: 'SentClientRequest',\n    enter: function() {\n      (async () => {\n        let message;\n        try {\n          message = await this.messageIo.readMessage();\n        } catch (err: any) {\n          return this.socketError(err);\n        }\n        // request timer is stopped on first data package\n        this.clearRequestTimer();\n\n        const tokenStreamParser = this.createTokenStreamParser(message, new RequestTokenHandler(this, this.request!));\n\n        // If the request was canceled and we have a `cancelTimer`\n        // defined, we send a attention message after the\n        // request message was fully sent off.\n        //\n        // We already started consuming the current message\n        // (but all the token handlers should be no-ops), and\n        // need to ensure the next message is handled by the\n        // `SENT_ATTENTION` state.\n        if (this.request?.canceled && this.cancelTimer) {\n          return this.transitionTo(this.STATE.SENT_ATTENTION);\n        }\n\n        const onResume = () => {\n          tokenStreamParser.resume();\n        };\n        const onPause = () => {\n          tokenStreamParser.pause();\n\n          this.request?.once('resume', onResume);\n        };\n\n        this.request?.on('pause', onPause);\n\n        if (this.request instanceof Request && this.request.paused) {\n          onPause();\n        }\n\n        const onCancel = () => {\n          tokenStreamParser.removeListener('end', onEndOfMessage);\n\n          if (this.request instanceof Request && this.request.paused) {\n            // resume the request if it was paused so we can read the remaining tokens\n            this.request.resume();\n          }\n\n          this.request?.removeListener('pause', onPause);\n          this.request?.removeListener('resume', onResume);\n\n          // The `_cancelAfterRequestSent` callback will have sent a\n          // attention message, so now we need to also switch to\n          // the `SENT_ATTENTION` state to make sure the attention ack\n          // message is processed correctly.\n          this.transitionTo(this.STATE.SENT_ATTENTION);\n        };\n\n        const onEndOfMessage = () => {\n          this.request?.removeListener('cancel', this._cancelAfterRequestSent);\n          this.request?.removeListener('cancel', onCancel);\n          this.request?.removeListener('pause', onPause);\n          this.request?.removeListener('resume', onResume);\n\n          this.transitionTo(this.STATE.LOGGED_IN);\n          const sqlRequest = this.request as Request;\n          this.request = undefined;\n          if (this.config.options.tdsVersion < '7_2' && sqlRequest.error && this.isSqlBatch) {\n            this.inTransaction = false;\n          }\n          sqlRequest.callback(sqlRequest.error, sqlRequest.rowCount, sqlRequest.rows);\n        };\n\n        tokenStreamParser.once('end', onEndOfMessage);\n        this.request?.once('cancel', onCancel);\n      })();\n\n    },\n    exit: function(nextState) {\n      this.clearRequestTimer();\n    },\n    events: {\n      socketError: function(err) {\n        const sqlRequest = this.request!;\n        this.request = undefined;\n        this.transitionTo(this.STATE.FINAL);\n\n        sqlRequest.callback(err);\n      }\n    }\n  },\n  SENT_ATTENTION: {\n    name: 'SentAttention',\n    enter: function() {\n      (async () => {\n        let message;\n        try {\n          message = await this.messageIo.readMessage();\n        } catch (err: any) {\n          return this.socketError(err);\n        }\n\n        const handler = new AttentionTokenHandler(this, this.request!);\n        const tokenStreamParser = this.createTokenStreamParser(message, handler);\n\n        await once(tokenStreamParser, 'end');\n        // 3.2.5.7 Sent Attention State\n        // Discard any data contained in the response, until we receive the attention response\n        if (handler.attentionReceived) {\n          this.clearCancelTimer();\n\n          const sqlRequest = this.request!;\n          this.request = undefined;\n          this.transitionTo(this.STATE.LOGGED_IN);\n\n          if (sqlRequest.error && sqlRequest.error instanceof RequestError && sqlRequest.error.code === 'ETIMEOUT') {\n            sqlRequest.callback(sqlRequest.error);\n          } else {\n            sqlRequest.callback(new RequestError('Canceled.', 'ECANCEL'));\n          }\n        }\n\n      })().catch((err) => {\n        process.nextTick(() => {\n          throw err;\n        });\n      });\n    },\n    events: {\n      socketError: function(err) {\n        const sqlRequest = this.request!;\n        this.request = undefined;\n\n        this.transitionTo(this.STATE.FINAL);\n\n        sqlRequest.callback(err);\n      }\n    }\n  },\n  FINAL: {\n    name: 'Final',\n    enter: function() {\n      this.cleanupConnection(CLEANUP_TYPE.NORMAL);\n    },\n    events: {\n      connectTimeout: function() {\n        // Do nothing, as the timer should be cleaned up.\n      },\n      message: function() {\n        // Do nothing\n      },\n      socketError: function() {\n        // Do nothing\n      }\n    }\n  }\n};\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,GAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,GAAA,GAAAC,uBAAA,CAAAH,OAAA;AACA,IAAAI,GAAA,GAAAD,uBAAA,CAAAH,OAAA;AACA,IAAAK,IAAA,GAAAN,sBAAA,CAAAC,OAAA;AAEA,IAAAM,UAAA,GAAAP,sBAAA,CAAAC,OAAA;AAGA,IAAAO,OAAA,GAAAP,OAAA;AAEA,IAAAQ,SAAA,GAAAR,OAAA;AAOA,IAAAS,SAAA,GAAAV,sBAAA,CAAAC,OAAA;AACA,IAAAU,MAAA,GAAAX,sBAAA,CAAAC,OAAA;AACA,IAAAW,OAAA,GAAAX,OAAA;AACA,IAAAY,eAAA,GAAAZ,OAAA;AACA,IAAAa,qBAAA,GAAAb,OAAA;AACA,IAAAc,OAAA,GAAAd,OAAA;AACA,IAAAe,gBAAA,GAAAhB,sBAAA,CAAAC,OAAA;AACA,IAAAgB,cAAA,GAAAjB,sBAAA,CAAAC,OAAA;AACA,IAAAiB,YAAA,GAAAlB,sBAAA,CAAAC,OAAA;AACA,IAAAkB,QAAA,GAAAnB,sBAAA,CAAAC,OAAA;AACA,IAAAmB,kBAAA,GAAApB,sBAAA,CAAAC,OAAA;AACA,IAAAoB,gBAAA,GAAArB,sBAAA,CAAAC,OAAA;AACA,IAAAqB,UAAA,GAAAtB,sBAAA,CAAAC,OAAA;AACA,IAAAsB,kBAAA,GAAAtB,OAAA;AACA,IAAAuB,YAAA,GAAAvB,OAAA;AACA,IAAAwB,OAAA,GAAAxB,OAAA;AACA,IAAAyB,UAAA,GAAAzB,OAAA;AACA,IAAA0B,QAAA,GAAA1B,OAAA;AACA,IAAA2B,YAAA,GAAA3B,OAAA;AACA,IAAA4B,QAAA,GAAA7B,sBAAA,CAAAC,OAAA;AAEA,IAAA6B,KAAA,GAAA7B,OAAA;AAGA,IAAA8B,oBAAA,GAAA9B,OAAA;AACA,IAAA+B,SAAA,GAAA/B,OAAA;AACA,IAAAgC,gBAAA,GAAAhC,OAAA;AAEA,IAAAiC,uBAAA,GAAAlC,sBAAA,CAAAC,OAAA;AAEA,IAAAkC,iBAAA,GAAAnC,sBAAA,CAAAC,OAAA;AACA,IAAAmC,QAAA,GAAAnC,OAAA;AACA,IAAAoC,IAAA,GAAApC,OAAA;AACA,IAAAqC,QAAA,GAAArC,OAAA;AAAuI,SAAAsC,yBAAAC,WAAA,eAAAC,OAAA,kCAAAC,iBAAA,OAAAD,OAAA,QAAAE,gBAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,WAAA,WAAAA,WAAA,GAAAG,gBAAA,GAAAD,iBAAA,KAAAF,WAAA;AAAA,SAAApC,wBAAAwC,GAAA,EAAAJ,WAAA,SAAAA,WAAA,IAAAI,GAAA,IAAAA,GAAA,CAAAC,UAAA,WAAAD,GAAA,QAAAA,GAAA,oBAAAA,GAAA,wBAAAA,GAAA,4BAAAE,OAAA,EAAAF,GAAA,UAAAG,KAAA,GAAAR,wBAAA,CAAAC,WAAA,OAAAO,KAAA,IAAAA,KAAA,CAAAC,GAAA,CAAAJ,GAAA,YAAAG,KAAA,CAAAE,GAAA,CAAAL,GAAA,SAAAM,MAAA,WAAAC,qBAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,GAAA,IAAAX,GAAA,QAAAW,GAAA,kBAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAd,GAAA,EAAAW,GAAA,SAAAI,IAAA,GAAAR,qBAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAV,GAAA,EAAAW,GAAA,cAAAI,IAAA,KAAAA,IAAA,CAAAV,GAAA,IAAAU,IAAA,CAAAC,GAAA,KAAAR,MAAA,CAAAC,cAAA,CAAAH,MAAA,EAAAK,GAAA,EAAAI,IAAA,YAAAT,MAAA,CAAAK,GAAA,IAAAX,GAAA,CAAAW,GAAA,SAAAL,MAAA,CAAAJ,OAAA,GAAAF,GAAA,MAAAG,KAAA,IAAAA,KAAA,CAAAa,GAAA,CAAAhB,GAAA,EAAAM,MAAA,YAAAA,MAAA;AAAA,SAAAlD,uBAAA4C,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAqEvI;;AA+BA;AACA;AACA;AACA,MAAMiB,wBAAwB,GAAG,EAAE,GAAG,IAAI;AAC1C;AACA;AACA;AACA,MAAMC,uBAAuB,GAAG,EAAE,GAAG,IAAI;AACzC;AACA;AACA;AACA,MAAMC,8BAA8B,GAAG,EAAE,GAAG,IAAI;AAChD;AACA;AACA;AACA,MAAMC,sBAAsB,GAAG,CAAC,GAAG,IAAI;AACvC;AACA;AACA;AACA,MAAMC,8BAA8B,GAAG,GAAG;AAC1C;AACA;AACA;AACA,MAAMC,mBAAmB,GAAG,CAAC,GAAG,IAAI;AACpC;AACA;AACA;AACA,MAAMC,gBAAgB,GAAG,UAAU;AACnC;AACA;AACA;AACA,MAAMC,iBAAiB,GAAG,CAAC;AAC3B;AACA;AACA;AACA,MAAMC,YAAY,GAAG,IAAI;AACzB;AACA;AACA;AACA,MAAMC,mBAAmB,GAAG,KAAK;AACjC;AACA;AACA;AACA,MAAMC,gBAAgB,GAAG,YAAY;AACrC;AACA;AACA;AACA,MAAMC,kBAAkB,GAAG,KAAK;;AA2MhC;AACA;AACA;;AA0cA;AACA;AACA;AACA,MAAMC,YAAY,GAAG;EACnBC,MAAM,EAAE,CAAC;EACTC,QAAQ,EAAE,CAAC;EACXC,KAAK,EAAE;AACT,CAAC;AAOD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,UAAU,SAASC,oBAAY,CAAC;EACpC;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAGE;AACF;AACA;;EAkBE;AACF;AACA;;EAGE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAGE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAGE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAEE;AACF;AACA;;EAGE;AACF;AACA;EACEC,uBAAuB;;EAEvB;AACF;AACA;;EAG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"} \ No newline at end of file diff --git a/samples/Javascript/clean/connection.js.simple b/samples/Javascript/clean/connection.js.simple new file mode 100644 index 000000000..68add63b9 --- /dev/null +++ b/samples/Javascript/clean/connection.js.simple @@ -0,0 +1,8 @@ +# Javascript/clean/connection.js +data/embedded/base64/terms +data/embedded/base64/url +encoding/base64 +fd/write +net/socket/send +ref/site/url +ref/words/password diff --git a/samples/Javascript/clean/napi_rs_runtime.js b/samples/Javascript/clean/napi_rs_runtime.js new file mode 100644 index 000000000..e06c158f4 --- /dev/null +++ b/samples/Javascript/clean/napi_rs_runtime.js @@ -0,0 +1,11538 @@ +/* eslint-disable no-undef */ +var _WebAssembly$1 = typeof WebAssembly !== 'undefined' + ? WebAssembly + : typeof WXWebAssembly !== 'undefined' + ? WXWebAssembly + : undefined; +function validateImports(imports) { + if (imports && typeof imports !== 'object') { + throw new TypeError('imports must be an object or undefined'); + } + return true; +} +function load(wasmInput, imports) { + if (!wasmInput) + throw new TypeError('Invalid wasm source'); + validateImports(imports); + imports = imports !== null && imports !== void 0 ? imports : {}; + // Promise + try { + var then = typeof wasmInput === 'object' && wasmInput !== null && 'then' in wasmInput ? wasmInput.then : undefined; + if (typeof then === 'function') { + return then.call(wasmInput, function (input) { return load(input, imports); }); + } + } + catch (_) { } + // BufferSource + if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) { + return _WebAssembly$1.instantiate(wasmInput, imports); + } + // WebAssembly.Module + if (wasmInput instanceof _WebAssembly$1.Module) { + return _WebAssembly$1.instantiate(wasmInput, imports).then(function (instance) { + return { instance: instance, module: wasmInput }; + }); + } + // Response + if (typeof Response !== 'undefined' && wasmInput instanceof Response) { + return wasmInput.arrayBuffer().then(function (buffer) { + return _WebAssembly$1.instantiate(buffer, imports); + }); + } + // string | URL + var inputIsString = typeof wasmInput === 'string'; + if (inputIsString || (typeof URL !== 'undefined' && wasmInput instanceof URL)) { + if (inputIsString && typeof wx !== 'undefined' && typeof __wxConfig !== 'undefined') { + return _WebAssembly$1.instantiate(wasmInput, imports); + } + if (typeof fetch !== 'function') { + throw new TypeError('wasm source can not be a string or URL in this environment'); + } + if (typeof _WebAssembly$1.instantiateStreaming === 'function') { + try { + return _WebAssembly$1.instantiateStreaming(fetch(wasmInput), imports).catch(function () { + return load(fetch(wasmInput), imports); + }); + } + catch (_) { + return load(fetch(wasmInput), imports); + } + } + else { + return load(fetch(wasmInput), imports); + } + } + throw new TypeError('Invalid wasm source'); +} +function loadSync(wasmInput, imports) { + if (!wasmInput) + throw new TypeError('Invalid wasm source'); + validateImports(imports); + imports = imports !== null && imports !== void 0 ? imports : {}; + var module; + if ((wasmInput instanceof ArrayBuffer) || ArrayBuffer.isView(wasmInput)) { + module = new _WebAssembly$1.Module(wasmInput); + } + else if (wasmInput instanceof WebAssembly.Module) { + module = wasmInput; + } + else { + throw new TypeError('Invalid wasm source'); + } + var instance = new _WebAssembly$1.Instance(module, imports); + var source = { instance: instance, module: module }; + return source; +} + +function createNapiModule(options) { + var napiModule = (function () { + var ENVIRONMENT_IS_NODE = null !== null ; + var ENVIRONMENT_IS_PTHREAD = Boolean(options.childThread); + var reuseWorker = Boolean(options.reuseWorker); + var wasmInstance; + var wasmModule; + var wasmMemory; + var wasmTable; + var _malloc; + var _free; + function abort(msg) { + if (typeof _WebAssembly$1.RuntimeError === 'function') { + throw new _WebAssembly$1.RuntimeError(msg); + } + throw Error(msg); + } + var napiModule = { + imports: { + env: {}, + napi: {}, + emnapi: {} + }, + exports: {}, + emnapi: {}, + loaded: false, + filename: '', + childThread: Boolean(options.childThread), + spawnThread: undefined, + startThread: undefined, + initWorker: undefined, + executeAsyncWork: undefined, + init: function (options) { + if (napiModule.loaded) + return napiModule.exports; + if (!options) + throw new TypeError('Invalid napi init options'); + var instance = options.instance; + if (!(instance === null || instance === void 0 ? void 0 : instance.exports)) + throw new TypeError('Invalid wasm instance'); + wasmInstance = instance; + var exports = instance.exports; + var module = options.module; + var memory = options.memory || exports.memory; + var table = options.table || exports.__indirect_function_table; + if (!(module instanceof _WebAssembly$1.Module)) + throw new TypeError('Invalid wasm module'); + if (!(memory instanceof _WebAssembly$1.Memory)) + throw new TypeError('Invalid wasm memory'); + if (!(table instanceof _WebAssembly$1.Table)) + throw new TypeError('Invalid wasm table'); + wasmModule = module; + wasmMemory = memory; + wasmTable = table; + if (typeof exports.malloc !== 'function') + throw new TypeError('malloc is not exported'); + if (typeof exports.free !== 'function') + throw new TypeError('free is not exported'); + _malloc = exports.malloc; + _free = exports.free; + if (!napiModule.childThread) { + // main thread only + var moduleApiVersion = 8 /* Version.NODE_API_DEFAULT_MODULE_API_VERSION */; + var node_api_module_get_api_version_v1 = instance.exports.node_api_module_get_api_version_v1; + if (typeof node_api_module_get_api_version_v1 === 'function') { + moduleApiVersion = node_api_module_get_api_version_v1(); + } + // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing + var envObject = napiModule.envObject || (napiModule.envObject = emnapiCtx.createEnv(napiModule.filename, moduleApiVersion, function (cb) { return (wasmTable.get(cb)); }, function (cb) { return (wasmTable.get(cb)); }, abort, emnapiNodeBinding)); + var scope_1 = emnapiCtx.openScope(envObject); + try { + envObject.callIntoModule(function (_envObject) { + var exports = napiModule.exports; + var exportsHandle = scope_1.add(exports); + var napi_register_wasm_v1 = instance.exports.napi_register_wasm_v1; + var napiValue = napi_register_wasm_v1(_envObject.id, exportsHandle.id); + napiModule.exports = (!napiValue) ? exports : emnapiCtx.handleStore.get(napiValue).value; + }); + } + finally { + emnapiCtx.closeScope(envObject, scope_1); + } + napiModule.loaded = true; + delete napiModule.envObject; + return napiModule.exports; + } + } + }; + var emnapiCtx; + var emnapiNodeBinding; + var onCreateWorker; + var err; + if (!ENVIRONMENT_IS_PTHREAD) { + var context = options.context; + if (typeof context !== 'object' || context === null) { + throw new TypeError("Invalid `options.context`. Use `import { getDefaultContext } from '@emnapi/runtime'`"); + } + emnapiCtx = context; + } + else { + emnapiCtx = options === null || options === void 0 ? void 0 : options.context; + var postMsg = typeof options.postMessage === 'function' + ? options.postMessage + : typeof postMessage === 'function' + ? postMessage + : undefined; + if (typeof postMsg !== 'function') { + throw new TypeError('No postMessage found'); + } + napiModule.postMessage = postMsg; + } + if (typeof options.filename === 'string') { + napiModule.filename = options.filename; + } + if (typeof options.onCreateWorker === 'function') { + onCreateWorker = options.onCreateWorker; + } + if (typeof options.print === 'function') { + options.print; + } + else { + console.log.bind(console); + } + if (typeof options.printErr === 'function') { + err = options.printErr; + } + else { + err = console.warn.bind(console); + } + 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; + } + var emnapiAsyncWorkPoolSize = 0; + 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 singleThreadAsyncWork = ENVIRONMENT_IS_PTHREAD ? false : (emnapiAsyncWorkPoolSize <= 0); + function _emnapi_async_work_pool_size() { + return Math.abs(emnapiAsyncWorkPoolSize); + } + napiModule.imports.env._emnapi_async_work_pool_size = _emnapi_async_work_pool_size; + // ------------------------------ pthread ------------------------------- + function emnapiAddSendListener(worker) { + if (!worker) + return false; + if (worker._emnapiSendListener) + return true; + var handler = function (e) { + var data = e.data; + var __emnapi__ = data.__emnapi__; + if (__emnapi__ && __emnapi__.type === 'async-send') { + if (ENVIRONMENT_IS_PTHREAD) { + var postMessage_1 = napiModule.postMessage; + postMessage_1({ __emnapi__: __emnapi__ }); + } + else { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var callback = __emnapi__.payload.callback; + (wasmTable.get(callback))(__emnapi__.payload.data); + } + } + }; + var dispose = function () { + { + worker.removeEventListener('message', handler, false); + } + delete worker._emnapiSendListener; + }; + worker._emnapiSendListener = { handler: handler, dispose: dispose }; + { + worker.addEventListener('message', handler, false); + } + return true; + } + napiModule.emnapi.addSendListener = emnapiAddSendListener; + function terminateWorker(worker) { + var tid = worker.__emnapi_tid; + worker.terminate(); + worker.onmessage = function (e) { + if (e.data.__emnapi__) { + err('received "' + e.data.__emnapi__.type + '" command from terminated worker: ' + tid); + } + }; + } + function spawnThread(startArg, errorOrTid) { + var isNewABI = errorOrTid !== undefined; + if (!isNewABI) { + errorOrTid = _malloc(8); + if (!errorOrTid) { + return -48; /* ENOMEM */ + } + } + var struct = new Int32Array(wasmMemory.buffer, errorOrTid, 2); + Atomics.store(struct, 0, 0); + Atomics.store(struct, 1, 0); + if (ENVIRONMENT_IS_PTHREAD) { + var postMessage_2 = napiModule.postMessage; + postMessage_2({ + __emnapi__: { + type: 'spawn-thread', + payload: { + startArg: startArg, + errorOrTid: errorOrTid + } + } + }); + Atomics.wait(struct, 1, 0); + var isError = Atomics.load(struct, 0); + var result = Atomics.load(struct, 1); + if (isNewABI) { + return isError; + } + _free(errorOrTid); + return isError ? -result : result; + } + var worker; + try { + worker = PThread.getNewWorker(); + if (!worker) { + throw new Error('failed to get new worker'); + } + } + catch (e) { + var EAGAIN = 6; + Atomics.store(struct, 0, 1); + Atomics.store(struct, 1, EAGAIN); + Atomics.notify(struct, 1); + err(e.message); + if (isNewABI) { + return 1; + } + _free(errorOrTid); + return -EAGAIN; + } + var tid = PThread.nextWorkerID + 43; + Atomics.store(struct, 0, 0); + Atomics.store(struct, 1, tid); + Atomics.notify(struct, 1); + var WASI_THREADS_MAX_TID = 0x1FFFFFFF; + PThread.nextWorkerID = (PThread.nextWorkerID + 1) % (WASI_THREADS_MAX_TID - 42); + PThread.pthreads[tid] = worker; + worker.__emnapi_tid = tid; + PThread.runningWorkers.push(worker); + worker.postMessage({ + __emnapi__: { + type: 'start', + payload: { + tid: tid, + arg: startArg + } + } + }); + if (isNewABI) { + return 0; + } + _free(errorOrTid); + return tid; + } + function startThread(tid, startArg) { + if (napiModule.childThread) { + if (typeof wasmInstance.exports.wasi_thread_start !== 'function') { + throw new TypeError('wasi_thread_start is not exported'); + } + var postMessage_3 = napiModule.postMessage; + wasmInstance.exports.wasi_thread_start(tid, startArg); + postMessage_3({ + __emnapi__: { + type: 'cleanup-thread', + payload: { + tid: tid + } + } + }); + } + else { + throw new Error('startThread is only available in child threads'); + } + } + napiModule.spawnThread = spawnThread; + napiModule.startThread = startThread; + var PThread = { + unusedWorkers: [], + runningWorkers: [], + pthreads: Object.create(null), + nextWorkerID: 0, + init: function () { }, + returnWorkerToPool: function (worker) { + var tid = worker.__emnapi_tid; + delete PThread.pthreads[tid]; + PThread.unusedWorkers.push(worker); + PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); + delete worker.__emnapi_tid; + }, + loadWasmModuleToWorker: function (worker) { + if (worker.whenLoaded) + return worker.whenLoaded; + worker.whenLoaded = new Promise(function (resolve, reject) { + worker.onmessage = function (e) { + if (e.data.__emnapi__) { + var type = e.data.__emnapi__.type; + var payload = e.data.__emnapi__.payload; + if (type === 'loaded') { + worker.loaded = true; + resolve(worker); + // if (payload.err) { + // err('failed to load in child thread: ' + (payload.err.message || payload.err)) + // } + } + else if (type === 'spawn-thread') { + spawnThread(payload.startArg, payload.errorOrTid); + } + else if (type === 'cleanup-thread') { + if (reuseWorker) { + PThread.returnWorkerToPool(worker); + } + else { + delete PThread.pthreads[payload.tid]; + PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1); + terminateWorker(worker); + delete worker.__emnapi_tid; + } + } + } + }; + worker.onerror = function (e) { + var message = 'worker sent an error!'; + // if (worker.pthread_ptr) { + // message = 'Pthread ' + ptrToString(worker.pthread_ptr) + ' sent an error!' + // } + err(message + ' ' + e.message); + reject(e); + throw e; + }; + // napiModule.emnapi.addSendListener(worker) + emnapiAddSendListener(worker); + // if (typeof emnapiTSFN !== 'undefined') { + // emnapiTSFN.addListener(worker) + // } + try { + worker.postMessage({ + __emnapi__: { + type: 'load', + payload: { + wasmModule: wasmModule, + wasmMemory: wasmMemory + } + } + }); + } + catch (err) { + if (typeof SharedArrayBuffer === 'undefined' || !(wasmMemory.buffer instanceof SharedArrayBuffer)) { + throw new Error('Multithread features require shared wasm memory. ' + + 'Try to compile with `-matomics -mbulk-memory` and use `--import-memory --shared-memory` during linking'); + } + throw err; + } + }); + return worker.whenLoaded; + }, + allocateUnusedWorker: function () { + if (typeof onCreateWorker !== 'function') { + throw new TypeError('`options.onCreateWorker` is not provided'); + } + var worker = onCreateWorker({ type: 'thread' }); + PThread.unusedWorkers.push(worker); + return worker; + }, + getNewWorker: function () { + if (reuseWorker) { + if (PThread.unusedWorkers.length === 0) { + var worker_1 = PThread.allocateUnusedWorker(); + PThread.loadWasmModuleToWorker(worker_1); + } + return PThread.unusedWorkers.pop(); + } + var worker = PThread.allocateUnusedWorker(); + PThread.loadWasmModuleToWorker(worker); + return worker; + } + }; + /** + * @__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) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var versions = [0, 0, 0]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setUint32(major, versions[0], true); + HEAP_DATA_VIEW.setUint32(minor, versions[1], true); + HEAP_DATA_VIEW.setUint32(patch, versions[2], true); + } + /** + * @__sig v + * @__deps $runtimeKeepalivePush + */ + function _emnapi_runtime_keepalive_push() { + } + /** + * @__sig v + * @__deps $runtimeKeepalivePop + */ + function _emnapi_runtime_keepalive_pop() { + } + /** + * @__sig vpp + */ + function _emnapi_set_immediate(callback, data) { + emnapiCtx.feature.setImmediate(function () { + (wasmTable.get(callback))(data); + }); + } + /** + * @__sig vpp + */ + function _emnapi_next_tick(callback, data) { + // eslint-disable-next-line @typescript-eslint/no-floating-promises + Promise.resolve().then(function () { + (wasmTable.get(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 () { + (wasmTable.get(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); + 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) + ]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, tempI64[0], true); + HEAP_DATA_VIEW.setInt32(result + 4, tempI64[1], true); + } + var utilMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + $emnapiSetValueI64: $emnapiSetValueI64, + _emnapi_call_finalizer: _emnapi_call_finalizer, + _emnapi_callback_into_module: _emnapi_callback_into_module, + _emnapi_ctx_decrease_waiting_request_counter: _emnapi_ctx_decrease_waiting_request_counter, + _emnapi_ctx_increase_waiting_request_counter: _emnapi_ctx_increase_waiting_request_counter, + _emnapi_get_node_version: _emnapi_get_node_version, + _emnapi_next_tick: _emnapi_next_tick, + _emnapi_runtime_keepalive_pop: _emnapi_runtime_keepalive_pop, + _emnapi_runtime_keepalive_push: _emnapi_runtime_keepalive_push, + _emnapi_set_immediate: _emnapi_set_immediate, + napi_clear_last_error: napi_clear_last_error, + napi_set_last_error: napi_set_last_error + }); + function emnapiGetWorkerByPthreadPtr(pthreadPtr) { + var view = new DataView(wasmMemory.buffer); + /** + * wasi-sdk-20.0+threads + * + * struct pthread { + * struct pthread *self; // 0 + * struct pthread *prev, *next; // 4, 8 + * uintptr_t sysinfo; // 12 + * uintptr_t canary; // 16 + * int tid; // 20 + * // ... + * } + */ + var tidOffset = 20; + var tid = view.getInt32(pthreadPtr + tidOffset, true); + var worker = PThread.pthreads[tid]; + return worker; + } + /** @__sig vp */ + function _emnapi_worker_unref(pthreadPtr) { + if (ENVIRONMENT_IS_PTHREAD) + return; + var worker = emnapiGetWorkerByPthreadPtr(pthreadPtr); + if (worker && typeof worker.unref === 'function') { + worker.unref(); + } + } + /** @__sig vipp */ + function _emnapi_async_send_js(type, callback, data) { + if (ENVIRONMENT_IS_PTHREAD) { + var postMessage_1 = napiModule.postMessage; + postMessage_1({ + __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; + } + } + } + // function ptrToString (ptr: number): string { + // return '0x' + ('00000000' + ptr.toString(16)).slice(-8) + // } + var uvThreadpoolReadyResolve; + var uvThreadpoolReady = new Promise(function (resolve) { + uvThreadpoolReadyResolve = function () { + uvThreadpoolReady.ready = true; + resolve(); + }; + }); + uvThreadpoolReady.ready = false; + /** @__sig i */ + function _emnapi_is_main_browser_thread() { + return (typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE) ? 1 : 0; + } + /** @__sig vppi */ + function _emnapi_after_uvthreadpool_ready(callback, q, type) { + if (uvThreadpoolReady.ready) { + (wasmTable.get(callback))(q, type); + } + else { + uvThreadpoolReady.then(function () { + (wasmTable.get(callback))(q, type); + }); + } + } + /** @__sig vpi */ + function _emnapi_tell_js_uvthreadpool(threads, size) { + var p = []; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + var _loop_1 = function (i) { + var pthreadPtr = HEAP_DATA_VIEW.getInt32(threads + i * 4, true); + var worker = emnapiGetWorkerByPthreadPtr(pthreadPtr); + p.push(new Promise(function (resolve) { + var handler = function (e) { + var data = e.data; + var __emnapi__ = data.__emnapi__; + if (__emnapi__ && __emnapi__.type === 'async-thread-ready') { + resolve(); + if (worker && typeof worker.unref === 'function') { + worker.unref(); + } + { + worker.removeEventListener('message', handler); + } + } + }; + { + worker.addEventListener('message', handler); + } + })); + }; + for (var i = 0; i < size; i++) { + _loop_1(i); + } + Promise.all(p).then(uvThreadpoolReadyResolve); + } + /** @__sig v */ + function _emnapi_emit_async_thread_ready() { + if (!ENVIRONMENT_IS_PTHREAD) + return; + var postMessage = napiModule.postMessage; + postMessage({ + __emnapi__: { + type: 'async-thread-ready', + payload: {} + } + }); + } + var asyncMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + _emnapi_after_uvthreadpool_ready: _emnapi_after_uvthreadpool_ready, + _emnapi_async_send_js: _emnapi_async_send_js, + _emnapi_emit_async_thread_ready: _emnapi_emit_async_thread_ready, + _emnapi_is_main_browser_thread: _emnapi_is_main_browser_thread, + _emnapi_tell_js_uvthreadpool: _emnapi_tell_js_uvthreadpool, + _emnapi_worker_unref: _emnapi_worker_unref + }); + /* eslint-disable @typescript-eslint/indent */ + /** @__sig ipjp */ + function napi_adjust_external_memory(env, change_in_bytes, adjusted_value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + var envObject = emnapiCtx.envStore.get(env); + if (!adjusted_value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var change_in_bytes_number = Number(change_in_bytes); + if (change_in_bytes_number < 0) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var old_size = wasmMemory.buffer.byteLength; + var new_size = old_size + change_in_bytes_number; + new_size = new_size + ((65536 - new_size % 65536) % 65536); + if (wasmMemory.grow((new_size - old_size + 65535) >> 16) === -1) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (emnapiCtx.feature.supportBigInt) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setBigInt64(adjusted_value, BigInt(wasmMemory.buffer.byteLength), true); + } + else { + $emnapiSetValueI64(adjusted_value, wasmMemory.buffer.byteLength); + } + return envObject.clearLastError(); + } + var memoryMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_adjust_external_memory: napi_adjust_external_memory + }); + /** + * @__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 () { + (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) { + 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 () { + (wasmTable.get(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 vppdp */ + function _emnapi_node_emit_async_init(async_resource, async_resource_name, trigger_async_id, result) { + if (!emnapiNodeBinding) + return; + var resource = emnapiCtx.handleStore.get(async_resource).value; + var resource_name = emnapiCtx.handleStore.get(async_resource_name).value; + var asyncContext = emnapiNodeBinding.node.emitAsyncInit(resource, resource_name, trigger_async_id); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var asyncId = asyncContext.asyncId; + var triggerAsyncId = asyncContext.triggerAsyncId; + if (result) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setFloat64(result, asyncId, true); + HEAP_DATA_VIEW.setFloat64(result + 8, triggerAsyncId, true); + } + } + /** @__sig vdd */ + function _emnapi_node_emit_async_destroy(async_id, trigger_async_id) { + if (!emnapiNodeBinding) + return; + emnapiNodeBinding.node.emitAsyncDestroy({ + asyncId: async_id, + triggerAsyncId: trigger_async_id + }); + } + /* vpddp export function _emnapi_node_open_callback_scope (async_resource: napi_value, async_id: double, trigger_async_id: double, result: Pointer): void { + if (!emnapiNodeBinding || !result) return + const resource = emnapiCtx.handleStore.get(async_resource)!.value + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const nativeCallbackScopePointer = emnapiNodeBinding.node.openCallbackScope(resource, { + asyncId: async_id, + triggerAsyncId: trigger_async_id + }) + + from64('result') + $_TODO_makeSetValue('result', 0, 'nativeCallbackScopePointer', 'i64') + } + + vp + export function _emnapi_node_close_callback_scope (scope: Pointer): void { + if (!emnapiNodeBinding || !scope) return + from64('scope') + const nativeCallbackScopePointer = $_TODO_makeGetValue('scope', 0, 'i64') + emnapiNodeBinding.node.closeCallbackScope(BigInt(nativeCallbackScopePointer)) + } */ + /** @__sig ipppppddp */ + function _emnapi_node_make_callback(env, async_resource, cb, argv, size, async_id, trigger_async_id, result) { + var i = 0; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v; + if (!emnapiNodeBinding) + return; + var resource = emnapiCtx.handleStore.get(async_resource).value; + var callback = emnapiCtx.handleStore.get(cb).value; + size = size >>> 0; + var arr = Array(size); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + for (; i < size; i++) { + var argVal = HEAP_DATA_VIEW.getInt32(argv + i * 4, true); + arr[i] = emnapiCtx.handleStore.get(argVal).value; + } + var ret = emnapiNodeBinding.node.makeCallback(resource, callback, arr, { + asyncId: async_id, + triggerAsyncId: trigger_async_id + }); + if (result) { + var envObject = emnapiCtx.envStore.get(env); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + v = envObject.ensureHandleId(ret); + HEAP_DATA_VIEW.setInt32(result, v, true); + } + } + /** @__sig ippp */ + function _emnapi_async_init_js(async_resource, async_resource_name, result) { + if (!emnapiNodeBinding) { + return 9 /* napi_status.napi_generic_failure */; + } + var resource; + if (async_resource) { + resource = Object(emnapiCtx.handleStore.get(async_resource).value); + } + var name = emnapiCtx.handleStore.get(async_resource_name).value; + var ret = emnapiNodeBinding.napi.asyncInit(resource, name); + if (ret.status !== 0) + return ret.status; + var numberValue = ret.value; + if (!((numberValue >= (BigInt(-1) * (BigInt(1) << BigInt(63)))) && (numberValue < (BigInt(1) << BigInt(63))))) { + numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + if (numberValue >= (BigInt(1) << BigInt(63))) { + numberValue = numberValue - (BigInt(1) << BigInt(64)); + } + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var low = Number(numberValue & BigInt(0xffffffff)); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var high = Number(numberValue >> BigInt(32)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, low, true); + HEAP_DATA_VIEW.setInt32(result + 4, high, true); + return 0 /* napi_status.napi_ok */; + } + /** @__sig ip */ + function _emnapi_async_destroy_js(async_context) { + if (!emnapiNodeBinding) { + return 9 /* napi_status.napi_generic_failure */; + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + var low = HEAP_DATA_VIEW.getInt32(async_context, true); + var high = HEAP_DATA_VIEW.getInt32(async_context + 4, true); + var pointer = BigInt(low >>> 0) | (BigInt(high) << BigInt(32)); + var ret = emnapiNodeBinding.napi.asyncDestroy(pointer); + if (ret.status !== 0) + return ret.status; + return 0 /* napi_status.napi_ok */; + } + // https://github.com/nodejs/node-addon-api/pull/1283 + /** @__sig ipppp */ + function napi_open_callback_scope(env, ignored, async_context_handle, result) { + throw new Error('napi_open_callback_scope has not been implemented yet'); + } + /** @__sig ipp */ + function napi_close_callback_scope(env, scope) { + throw new Error('napi_close_callback_scope has not been implemented yet'); + } + /** @__sig ippppppp */ + function napi_make_callback(env, async_context, recv, func, argc, argv, result) { + var i = 0; + // 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!emnapiNodeBinding) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!recv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (argc > 0) { + if (!argv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var v8recv = Object(emnapiCtx.handleStore.get(recv).value); + var v8func = emnapiCtx.handleStore.get(func).value; + if (typeof v8func !== 'function') { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + var low = HEAP_DATA_VIEW.getInt32(async_context, true); + var high = HEAP_DATA_VIEW.getInt32(async_context + 4, true); + var ctx = BigInt(low >>> 0) | (BigInt(high) << BigInt(32)); + argc = argc >>> 0; + var arr = Array(argc); + for (; i < argc; i++) { + var argVal = HEAP_DATA_VIEW.getInt32(argv + i * 4, true); + arr[i] = emnapiCtx.handleStore.get(argVal).value; + } + var ret = emnapiNodeBinding.napi.makeCallback(ctx, v8recv, v8func, arr); + if (ret.error) { + throw ret.error; + } + if (ret.status !== 0 /* napi_status.napi_ok */) + return envObject.setLastError(ret.status); + if (result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + v = envObject.ensureHandleId(ret.value); + HEAP_DATA_VIEW.setInt32(result, v, true); + } + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig vp */ + function _emnapi_env_check_gc_access(env) { + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + } + var nodeMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + _emnapi_async_destroy_js: _emnapi_async_destroy_js, + _emnapi_async_init_js: _emnapi_async_init_js, + _emnapi_env_check_gc_access: _emnapi_env_check_gc_access, + _emnapi_node_emit_async_destroy: _emnapi_node_emit_async_destroy, + _emnapi_node_emit_async_init: _emnapi_node_emit_async_init, + _emnapi_node_make_callback: _emnapi_node_make_callback, + napi_close_callback_scope: napi_close_callback_scope, + napi_make_callback: napi_make_callback, + napi_open_callback_scope: napi_open_callback_scope + }); + /** + * @__deps malloc + * @__deps free + * @__postset + * ``` + * emnapiTSFN.init(); + * ``` + */ + var emnapiTSFN = { + offset: { + /* napi_ref */ resource: 0, + /* double */ async_id: 8, + /* double */ trigger_async_id: 16, + /* size_t */ queue_size: 24, + /* void* */ queue: 1 * 4 + 24, + /* size_t */ thread_count: 2 * 4 + 24, + /* bool */ is_closing: 3 * 4 + 24, + /* atomic_uchar */ dispatch_state: 3 * 4 + 28, + /* void* */ context: 3 * 4 + 32, + /* size_t */ max_queue_size: 4 * 4 + 32, + /* napi_ref */ ref: 5 * 4 + 32, + /* napi_env */ env: 6 * 4 + 32, + /* void* */ finalize_data: 7 * 4 + 32, + /* napi_finalize */ finalize_cb: 8 * 4 + 32, + /* napi_threadsafe_function_call_js */ call_js_cb: 9 * 4 + 32, + /* bool */ handles_closing: 10 * 4 + 32, + /* bool */ async_ref: 10 * 4 + 36, + /* int32_t */ mutex: 10 * 4 + 40, + /* int32_t */ cond: 10 * 4 + 44, + end: 10 * 4 + 48 + }, + init: function () { + if (typeof PThread !== 'undefined') { + PThread.unusedWorkers.forEach(emnapiTSFN.addListener); + PThread.runningWorkers.forEach(emnapiTSFN.addListener); + var __original_getNewWorker_1 = PThread.getNewWorker; + PThread.getNewWorker = function () { + var r = __original_getNewWorker_1.apply(this, arguments); + emnapiTSFN.addListener(r); + return r; + }; + } + }, + addListener: function (worker) { + if (!worker) + return false; + if (worker._emnapiTSFNListener) + return true; + var handler = function (e) { + var data = e.data; + var __emnapi__ = data.__emnapi__; + if (__emnapi__) { + var type = __emnapi__.type; + var payload = __emnapi__.payload; + if (type === 'tsfn-send') { + emnapiTSFN.dispatch(payload.tsfn); + } + } + }; + var dispose = function () { + { + worker.removeEventListener('message', handler, false); + } + delete worker._emnapiTSFNListener; + }; + worker._emnapiTSFNListener = { handler: handler, dispose: dispose }; + { + worker.addEventListener('message', handler, false); + } + return true; + }, + initQueue: function (func) { + var size = 2 * 4; + var queue = _malloc(size); + if (!queue) + return false; + new Uint8Array(wasmMemory.buffer, queue, size).fill(0); + emnapiTSFN.storeSizeTypeValue(func + emnapiTSFN.offset.queue, queue, false); + return true; + }, + destroyQueue: function (func) { + var queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false); + if (queue) { + _free(queue); + } + }, + pushQueue: function (func, data) { + var queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false); + var head = emnapiTSFN.loadSizeTypeValue(queue, false); + var tail = emnapiTSFN.loadSizeTypeValue(queue + 4, false); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var size = 2 * 4; + var node = _malloc(size); + if (!node) + throw new Error('OOM'); + 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: function (func) { + var queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false); + var head = emnapiTSFN.loadSizeTypeValue(queue, false); + if (head === 0) + return 0; + var node = head; + var next = emnapiTSFN.loadSizeTypeValue(head + 4, false); + emnapiTSFN.storeSizeTypeValue(queue, next, false); + if (next === 0) { + emnapiTSFN.storeSizeTypeValue(queue + 4, 0, false); + } + emnapiTSFN.storeSizeTypeValue(node + 4, 0, false); + var value = emnapiTSFN.loadSizeTypeValue(node, false); + _free(node); + emnapiTSFN.subQueueSize(func); + return value; + }, + push: function (func, data, mode) { + var mutex = emnapiTSFN.getMutex(func); + var cond = emnapiTSFN.getCond(func); + var waitCondition = function () { + var queueSize = emnapiTSFN.getQueueSize(func); + var maxSize = emnapiTSFN.getMaxQueueSize(func); + var isClosing = emnapiTSFN.getIsClosing(func); + return queueSize >= maxSize && maxSize > 0 && !isClosing; + }; + var isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE; + return mutex.execute(function () { + while (waitCondition()) { + if (mode === 0 /* napi_threadsafe_function_call_mode.napi_tsfn_nonblocking */) { + return 15 /* napi_status.napi_queue_full */; + } + /** + * Browser JS main thread can not use `Atomics.wait` + * + * Related: + * https://github.com/nodejs/node/pull/32689 + * https://github.com/nodejs/node/pull/33453 + */ + if (isBrowserMain) { + return 21 /* napi_status.napi_would_deadlock */; + } + cond.wait(); + } + if (emnapiTSFN.getIsClosing(func)) { + if (emnapiTSFN.getThreadCount(func) === 0) { + return 1 /* napi_status.napi_invalid_arg */; + } + else { + emnapiTSFN.subThreadCount(func); + return 16 /* napi_status.napi_closing */; + } + } + else { + emnapiTSFN.pushQueue(func, data); + emnapiTSFN.send(func); + return 0 /* napi_status.napi_ok */; + } + }); + }, + getMutex: function (func) { + var index = func + emnapiTSFN.offset.mutex; + var mutex = { + lock: function () { + var isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE; + var i32a = new Int32Array(wasmMemory.buffer, index, 1); + if (isBrowserMain) { + while (true) { + var oldValue = Atomics.compareExchange(i32a, 0, 0, 1); + if (oldValue === 0) { + return; + } + } + } + else { + while (true) { + var oldValue = Atomics.compareExchange(i32a, 0, 0, 1); + if (oldValue === 0) { + return; + } + Atomics.wait(i32a, 0, 1); + } + } + }, + /* lockAsync () { + return new Promise(resolve => { + const again = (): void => { fn() } + const fn = (): void => { + const i32a = new Int32Array(wasmMemory.buffer, index, 1) + const oldValue = Atomics.compareExchange(i32a, 0, 0, 1) + if (oldValue === 0) { + resolve() + return + } + (Atomics as any).waitAsync(i32a, 0, 1).value.then(again) + } + fn() + }) + }, */ + unlock: function () { + var i32a = new Int32Array(wasmMemory.buffer, index, 1); + var oldValue = Atomics.compareExchange(i32a, 0, 1, 0); + if (oldValue !== 1) { + throw new Error('Tried to unlock while not holding the mutex'); + } + Atomics.notify(i32a, 0, 1); + }, + execute: function (fn) { + mutex.lock(); + try { + return fn(); + } + finally { + mutex.unlock(); + } + } /* , + executeAsync (fn: () => Promise): Promise { + return mutex.lockAsync().then(() => { + const r = fn() + mutex.unlock() + return r + }, (err) => { + mutex.unlock() + throw err + }) + } */ + }; + return mutex; + }, + getCond: function (func) { + var index = func + emnapiTSFN.offset.cond; + var mutex = emnapiTSFN.getMutex(func); + var cond = { + wait: function () { + var i32a = new Int32Array(wasmMemory.buffer, index, 1); + var value = Atomics.load(i32a, 0); + mutex.unlock(); + Atomics.wait(i32a, 0, value); + mutex.lock(); + }, + /* waitAsync () { + const i32a = new Int32Array(wasmMemory.buffer, index, 1) + const value = Atomics.load(i32a, 0) + mutex.unlock() + const lock = (): Promise => mutex.lockAsync() + try { + return (Atomics as any).waitAsync(i32a, 0, value).value.then(lock, lock) + } catch (err) { + return lock() + } + }, */ + signal: function () { + var i32a = new Int32Array(wasmMemory.buffer, index, 1); + Atomics.add(i32a, 0, 1); + Atomics.notify(i32a, 0, 1); + } + }; + return cond; + }, + getQueueSize: function (func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue_size, true); + }, + addQueueSize: function (func) { + var offset = emnapiTSFN.offset.queue_size; + var arr, index; + arr = new Uint32Array(wasmMemory.buffer); + index = (func + offset) >> 2; + Atomics.add(arr, index, 1); + }, + subQueueSize: function (func) { + var offset = emnapiTSFN.offset.queue_size; + var arr, index; + arr = new Uint32Array(wasmMemory.buffer); + index = (func + offset) >> 2; + Atomics.sub(arr, index, 1); + }, + getThreadCount: function (func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.thread_count, true); + }, + addThreadCount: function (func) { + var offset = emnapiTSFN.offset.thread_count; + var arr, index; + arr = new Uint32Array(wasmMemory.buffer); + index = (func + offset) >> 2; + Atomics.add(arr, index, 1); + }, + subThreadCount: function (func) { + var offset = emnapiTSFN.offset.thread_count; + var arr, index; + arr = new Uint32Array(wasmMemory.buffer); + index = (func + offset) >> 2; + Atomics.sub(arr, index, 1); + }, + getIsClosing: function (func) { + return Atomics.load(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.is_closing) >> 2); + }, + setIsClosing: function (func, value) { + Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.is_closing) >> 2, value); + }, + getHandlesClosing: function (func) { + return Atomics.load(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.handles_closing) >> 2); + }, + setHandlesClosing: function (func, value) { + Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.handles_closing) >> 2, value); + }, + getDispatchState: function (func) { + return Atomics.load(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >> 2); + }, + getContext: function (func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.context, false); + }, + getMaxQueueSize: function (func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.max_queue_size, true); + }, + getEnv: function (func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.env, false); + }, + getCallJSCb: function (func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.call_js_cb, false); + }, + getRef: function (func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.ref, false); + }, + getResource: function (func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.resource, false); + }, + getFinalizeCb: function (func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_cb, false); + }, + getFinalizeData: function (func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_data, false); + }, + loadSizeTypeValue: function (offset, unsigned) { + var ret; + var arr; + if (unsigned) { + arr = new Uint32Array(wasmMemory.buffer); + ret = Atomics.load(arr, offset >> 2); + return ret; + } + else { + arr = new Int32Array(wasmMemory.buffer); + ret = Atomics.load(arr, offset >> 2); + return ret; + } + }, + storeSizeTypeValue: function (offset, value, unsigned) { + var arr; + if (unsigned) { + arr = new Uint32Array(wasmMemory.buffer); + Atomics.store(arr, offset >> 2, value); + return undefined; + } + else { + arr = new Int32Array(wasmMemory.buffer); + Atomics.store(arr, offset >> 2, value >>> 0); + return undefined; + } + }, + destroy: function (func) { + emnapiTSFN.destroyQueue(func); + var env = emnapiTSFN.getEnv(func); + var envObject = emnapiCtx.envStore.get(env); + var ref = emnapiTSFN.getRef(func); + if (ref) { + emnapiCtx.refStore.get(ref).dispose(); + } + emnapiCtx.removeCleanupHook(envObject, emnapiTSFN.cleanup, func); + envObject.unref(); + var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >> 2; + var arr = new Int32Array(wasmMemory.buffer); + if (Atomics.load(arr, asyncRefOffset)) { + Atomics.store(arr, asyncRefOffset, 0); + emnapiCtx.decreaseWaitingRequestCounter(); + } + var resource = emnapiTSFN.getResource(func); + emnapiCtx.refStore.get(resource).dispose(); + if (emnapiNodeBinding) { + var view = new DataView(wasmMemory.buffer); + var asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true); + var triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true); + _emnapi_node_emit_async_destroy(asyncId, triggerAsyncId); + } + _free(func); + }, + emptyQueueAndDelete: function (func) { + var callJsCb = emnapiTSFN.getCallJSCb(func); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var context = emnapiTSFN.getContext(func); + var data; + while (emnapiTSFN.getQueueSize(func) > 0) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + data = emnapiTSFN.shiftQueue(func); + if (callJsCb) { + (wasmTable.get(callJsCb))(0, 0, context, data); + } + } + emnapiTSFN.destroy(func); + }, + finalize: function (func) { + var env = emnapiTSFN.getEnv(func); + var envObject = emnapiCtx.envStore.get(env); + emnapiCtx.openScope(envObject); + var finalize = emnapiTSFN.getFinalizeCb(func); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var data = emnapiTSFN.getFinalizeData(func); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var context = emnapiTSFN.getContext(func); + var f = function () { + envObject.callFinalizerInternal(0, finalize, data, context); + }; + try { + if (finalize) { + if (emnapiNodeBinding) { + var resource = emnapiTSFN.getResource(func); + var resource_value = emnapiCtx.refStore.get(resource).get(); + var resourceObject = emnapiCtx.handleStore.get(resource_value).value; + var view = new DataView(wasmMemory.buffer); + var asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true); + var triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true); + emnapiNodeBinding.node.makeCallback(resourceObject, f, [], { + asyncId: asyncId, + triggerAsyncId: triggerAsyncId + }); + } + else { + f(); + } + } + emnapiTSFN.emptyQueueAndDelete(func); + } + finally { + emnapiCtx.closeScope(envObject); + } + }, + cleanup: function (func) { + emnapiTSFN.closeHandlesAndMaybeDelete(func, 1); + }, + closeHandlesAndMaybeDelete: function (func, set_closing) { + var env = emnapiTSFN.getEnv(func); + var envObject = emnapiCtx.envStore.get(env); + emnapiCtx.openScope(envObject); + try { + if (set_closing) { + emnapiTSFN.getMutex(func).execute(function () { + emnapiTSFN.setIsClosing(func, 1); + if (emnapiTSFN.getMaxQueueSize(func) > 0) { + emnapiTSFN.getCond(func).signal(); + } + }); + } + if (emnapiTSFN.getHandlesClosing(func)) { + return; + } + emnapiTSFN.setHandlesClosing(func, 1); + emnapiCtx.feature.setImmediate(function () { + emnapiTSFN.finalize(func); + }); + } + finally { + emnapiCtx.closeScope(envObject); + } + }, + dispatchOne: function (func) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var data = 0; + var popped_value = false; + var has_more = false; + var mutex = emnapiTSFN.getMutex(func); + var cond = emnapiTSFN.getCond(func); + mutex.execute(function () { + if (emnapiTSFN.getIsClosing(func)) { + emnapiTSFN.closeHandlesAndMaybeDelete(func, 0); + } + else { + var size = emnapiTSFN.getQueueSize(func); + if (size > 0) { + data = emnapiTSFN.shiftQueue(func); + popped_value = true; + var maxQueueSize = emnapiTSFN.getMaxQueueSize(func); + if (size === maxQueueSize && maxQueueSize > 0) { + cond.signal(); + } + size--; + } + if (size === 0) { + if (emnapiTSFN.getThreadCount(func) === 0) { + emnapiTSFN.setIsClosing(func, 1); + if (emnapiTSFN.getMaxQueueSize(func) > 0) { + cond.signal(); + } + emnapiTSFN.closeHandlesAndMaybeDelete(func, 0); + } + } + else { + has_more = true; + } + } + }); + if (popped_value) { + var env = emnapiTSFN.getEnv(func); + var envObject_1 = emnapiCtx.envStore.get(env); + emnapiCtx.openScope(envObject_1); + var f = function () { + envObject_1.callbackIntoModule(false, function () { + var callJsCb = emnapiTSFN.getCallJSCb(func); + var ref = emnapiTSFN.getRef(func); + var js_callback = ref ? emnapiCtx.refStore.get(ref).get() : 0; + if (callJsCb) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var context = emnapiTSFN.getContext(func); + (wasmTable.get(callJsCb))(env, js_callback, context, data); + } + else { + var jsCallback = js_callback ? emnapiCtx.handleStore.get(js_callback).value : null; + if (typeof jsCallback === 'function') { + jsCallback(); + } + } + }); + }; + try { + if (emnapiNodeBinding) { + var resource = emnapiTSFN.getResource(func); + var resource_value = emnapiCtx.refStore.get(resource).get(); + var resourceObject = emnapiCtx.handleStore.get(resource_value).value; + var view = new DataView(wasmMemory.buffer); + emnapiNodeBinding.node.makeCallback(resourceObject, f, [], { + asyncId: view.getFloat64(func + emnapiTSFN.offset.async_id, true), + triggerAsyncId: view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true) + }); + } + else { + f(); + } + } + finally { + emnapiCtx.closeScope(envObject_1); + } + } + return has_more; + }, + dispatch: function (func) { + var has_more = true; + var iterations_left = 1000; + var ui32a = new Uint32Array(wasmMemory.buffer); + var index = (func + emnapiTSFN.offset.dispatch_state) >> 2; + while (has_more && --iterations_left !== 0) { + Atomics.store(ui32a, index, 1); + has_more = emnapiTSFN.dispatchOne(func); + if (Atomics.exchange(ui32a, index, 0) !== 1) { + has_more = true; + } + } + if (has_more) { + emnapiTSFN.send(func); + } + }, + send: function (func) { + var current_state = Atomics.or(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >> 2, 1 << 1); + if ((current_state & 1) === 1) { + return; + } + if ((typeof ENVIRONMENT_IS_PTHREAD !== 'undefined') && ENVIRONMENT_IS_PTHREAD) { + postMessage({ + __emnapi__: { + type: 'tsfn-send', + payload: { + tsfn: func + } + } + }); + } + else { + emnapiCtx.feature.setImmediate(function () { + emnapiTSFN.dispatch(func); + }); + } + } + }; + /** @__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 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!async_resource_name) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + max_queue_size = max_queue_size >>> 0; + initial_thread_count = initial_thread_count >>> 0; + if (initial_thread_count === 0) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var ref = 0; + if (!func) { + if (!call_js_cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + else { + var funcValue = emnapiCtx.handleStore.get(func).value; + if (typeof funcValue !== 'function') { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + ref = emnapiCtx.createReference(envObject, func, 1, 1 /* Ownership.kUserland */).id; + } + var asyncResourceObject; + if (async_resource) { + asyncResourceObject = emnapiCtx.handleStore.get(async_resource).value; + if (asyncResourceObject == null) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + asyncResourceObject = Object(asyncResourceObject); + } + else { + asyncResourceObject = {}; + } + var resource = envObject.ensureHandleId(asyncResourceObject); + var asyncResourceName = emnapiCtx.handleStore.get(async_resource_name).value; + if (typeof asyncResourceName === 'symbol') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + asyncResourceName = String(asyncResourceName); + var resource_name = envObject.ensureHandleId(asyncResourceName); + // tsfn create + var sizeofTSFN = emnapiTSFN.offset.end; + var tsfn = _malloc(sizeofTSFN); + if (!tsfn) + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + new Uint8Array(wasmMemory.buffer).subarray(tsfn, tsfn + sizeofTSFN).fill(0); + var resourceRef = emnapiCtx.createReference(envObject, resource, 1, 1 /* Ownership.kUserland */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var resource_ = resourceRef.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(tsfn, resource_, true); + if (!emnapiTSFN.initQueue(tsfn)) { + _free(tsfn); + resourceRef.dispose(); + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + _emnapi_node_emit_async_init(resource, resource_name, -1, tsfn + emnapiTSFN.offset.async_id); + HEAP_DATA_VIEW.setUint32(tsfn + emnapiTSFN.offset.thread_count, initial_thread_count, true); + HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.context, context, true); + HEAP_DATA_VIEW.setUint32(tsfn + emnapiTSFN.offset.max_queue_size, max_queue_size, true); + HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.ref, ref, true); + HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.env, env, true); + HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.finalize_data, thread_finalize_data, true); + HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.finalize_cb, thread_finalize_cb, true); + HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.call_js_cb, call_js_cb, true); + emnapiCtx.addCleanupHook(envObject, emnapiTSFN.cleanup, tsfn); + envObject.ref(); + emnapiCtx.increaseWaitingRequestCounter(); + HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.async_ref, 1, true); + HEAP_DATA_VIEW.setInt32(result, tsfn, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_threadsafe_function_context(func, result) { + if (!func || !result) { + abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var context = emnapiTSFN.getContext(func); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, context, true); + return 0 /* napi_status.napi_ok */; + } + /** @__sig ippi */ + function napi_call_threadsafe_function(func, data, mode) { + if (!func) { + abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + return emnapiTSFN.push(func, data, mode); + } + /** @__sig ip */ + function napi_acquire_threadsafe_function(func) { + if (!func) { + abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + var mutex = emnapiTSFN.getMutex(func); + return mutex.execute(function () { + if (emnapiTSFN.getIsClosing(func)) { + return 16 /* napi_status.napi_closing */; + } + emnapiTSFN.addThreadCount(func); + return 0 /* napi_status.napi_ok */; + }); + } + /** @__sig ipi */ + function napi_release_threadsafe_function(func, mode) { + if (!func) { + abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + var mutex = emnapiTSFN.getMutex(func); + var cond = emnapiTSFN.getCond(func); + return mutex.execute(function () { + if (emnapiTSFN.getThreadCount(func) === 0) { + return 1 /* napi_status.napi_invalid_arg */; + } + emnapiTSFN.subThreadCount(func); + if (emnapiTSFN.getThreadCount(func) === 0 || mode === 1 /* napi_threadsafe_function_release_mode.napi_tsfn_abort */) { + var isClosing = emnapiTSFN.getIsClosing(func); + if (!isClosing) { + var isClosingValue = (mode === 1 /* napi_threadsafe_function_release_mode.napi_tsfn_abort */) ? 1 : 0; + emnapiTSFN.setIsClosing(func, isClosingValue); + if (isClosingValue && emnapiTSFN.getMaxQueueSize(func) > 0) { + cond.signal(); + } + emnapiTSFN.send(func); + } + } + return 0 /* napi_status.napi_ok */; + }); + } + /** @__sig ipp */ + function napi_unref_threadsafe_function(env, func) { + if (!func) { + abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >> 2; + var arr = new Int32Array(wasmMemory.buffer); + if (Atomics.load(arr, asyncRefOffset)) { + Atomics.store(arr, asyncRefOffset, 0); + emnapiCtx.decreaseWaitingRequestCounter(); + } + return 0 /* napi_status.napi_ok */; + } + /** @__sig ipp */ + function napi_ref_threadsafe_function(env, func) { + if (!func) { + abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >> 2; + var arr = new Int32Array(wasmMemory.buffer); + if (!Atomics.load(arr, asyncRefOffset)) { + Atomics.store(arr, asyncRefOffset, 1); + emnapiCtx.increaseWaitingRequestCounter(); + } + return 0 /* napi_status.napi_ok */; + } + var emnapiAWMT = { + unusedWorkers: [], + runningWorkers: [], + workQueue: [], + workerReady: null, + offset: { + /* napi_ref */ resource: 0, + /* double */ async_id: 8, + /* double */ trigger_async_id: 16, + /* napi_env */ env: 24, + /* void* */ data: 1 * 4 + 24, + /* napi_async_execute_callback */ execute: 2 * 4 + 24, + /* napi_async_complete_callback */ complete: 3 * 4 + 24, + end: 4 * 4 + 24 + }, + init: function () { + emnapiAWMT.unusedWorkers = []; + emnapiAWMT.runningWorkers = []; + emnapiAWMT.workQueue = []; + emnapiAWMT.workerReady = null; + }, + addListener: function (worker) { + if (!worker) + return false; + if (worker._emnapiAWMTListener) + return true; + var handler = function (e) { + var data = e.data; + var __emnapi__ = data.__emnapi__; + if (__emnapi__) { + var type = __emnapi__.type; + var payload = __emnapi__.payload; + if (type === 'async-work-complete') { + emnapiCtx.decreaseWaitingRequestCounter(); + emnapiAWMT.runningWorkers.splice(emnapiAWMT.runningWorkers.indexOf(worker), 1); + emnapiAWMT.unusedWorkers.push(worker); + emnapiAWMT.checkIdleWorker(); + emnapiAWMT.callComplete(payload.work, 0 /* napi_status.napi_ok */); + } + else if (type === 'async-work-queue') { + emnapiAWMT.scheduleWork(payload.work); + } + else if (type === 'async-work-cancel') { + emnapiAWMT.cancelWork(payload.work); + } + } + }; + var dispose = function () { + { + worker.removeEventListener('message', handler, false); + } + delete worker._emnapiAWMTListener; + }; + worker._emnapiAWMTListener = { handler: handler, dispose: dispose }; + { + worker.addEventListener('message', handler, false); + } + return true; + }, + initWorkers: function (n) { + if (ENVIRONMENT_IS_PTHREAD) { + // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing + return emnapiAWMT.workerReady || (emnapiAWMT.workerReady = Promise.resolve()); + } + if (emnapiAWMT.workerReady) + return emnapiAWMT.workerReady; + if (typeof onCreateWorker !== 'function') { + throw new TypeError('`options.onCreateWorker` is not a function'); + } + var promises = []; + var args = []; + if (!('emnapi_async_worker_create' in wasmInstance.exports)) { + throw new TypeError('`emnapi_async_worker_create` is not exported, please try to add `--export=emnapi_async_worker_create` to linker flags'); + } + for (var i = 0; i < n; ++i) { + args.push(wasmInstance.exports.emnapi_async_worker_create()); + } + try { + var _loop_1 = function (i) { + var worker = onCreateWorker({ type: 'async-work' }); + var p = PThread.loadWasmModuleToWorker(worker); + emnapiAWMT.addListener(worker); + promises.push(p.then(function () { + if (typeof worker.unref === 'function') { + worker.unref(); + } + })); + emnapiAWMT.unusedWorkers.push(worker); + var arg = args[i]; + worker.threadBlockBase = arg; + worker.postMessage({ + __emnapi__: { + type: 'async-worker-init', + payload: { arg: arg } + } + }); + }; + for (var i = 0; i < n; ++i) { + _loop_1(i); + } + } + catch (err) { + for (var i = 0; i < n; ++i) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var arg = args[i]; + _free(arg); + } + throw err; + } + emnapiAWMT.workerReady = Promise.all(promises); + return emnapiAWMT.workerReady; + }, + checkIdleWorker: function () { + if (emnapiAWMT.unusedWorkers.length > 0 && emnapiAWMT.workQueue.length > 0) { + var worker = emnapiAWMT.unusedWorkers.shift(); + var work = emnapiAWMT.workQueue.shift(); + emnapiAWMT.runningWorkers.push(worker); + worker.postMessage({ + __emnapi__: { + type: 'async-work-execute', + payload: { work: work } + } + }); + } + }, + getResource: function (work) { + return emnapiTSFN.loadSizeTypeValue(work + emnapiAWMT.offset.resource, false); + }, + getExecute: function (work) { + return emnapiTSFN.loadSizeTypeValue(work + emnapiAWMT.offset.execute, false); + }, + getComplete: function (work) { + return emnapiTSFN.loadSizeTypeValue(work + emnapiAWMT.offset.complete, false); + }, + getEnv: function (work) { + return emnapiTSFN.loadSizeTypeValue(work + emnapiAWMT.offset.env, false); + }, + getData: function (work) { + return emnapiTSFN.loadSizeTypeValue(work + emnapiAWMT.offset.data, false); + }, + scheduleWork: function (work) { + var _a; + if (ENVIRONMENT_IS_PTHREAD) { + var postMessage_1 = napiModule.postMessage; + postMessage_1({ + __emnapi__: { + type: 'async-work-queue', + payload: { work: work } + } + }); + return; + } + emnapiCtx.increaseWaitingRequestCounter(); + emnapiAWMT.workQueue.push(work); + if ((_a = emnapiAWMT.workerReady) === null || _a === void 0 ? void 0 : _a.ready) { + emnapiAWMT.checkIdleWorker(); + } + else { + var fail = function (err) { + emnapiCtx.decreaseWaitingRequestCounter(); + throw err; + }; + try { + emnapiAWMT.initWorkers(_emnapi_async_work_pool_size()).then(function () { + emnapiAWMT.workerReady.ready = true; + emnapiAWMT.checkIdleWorker(); + }, fail); + } + catch (err) { + fail(err); + } + } + }, + cancelWork: function (work) { + if (ENVIRONMENT_IS_PTHREAD) { + var postMessage_2 = napiModule.postMessage; + postMessage_2({ + __emnapi__: { + type: 'async-work-cancel', + payload: { work: work } + } + }); + return 0 /* napi_status.napi_ok */; + } + var index = emnapiAWMT.workQueue.indexOf(work); + if (index !== -1) { + emnapiAWMT.workQueue.splice(index, 1); + emnapiCtx.feature.setImmediate(function () { + emnapiCtx.decreaseWaitingRequestCounter(); + emnapiAWMT.checkIdleWorker(); + emnapiAWMT.callComplete(work, 11 /* napi_status.napi_cancelled */); + }); + return 0 /* napi_status.napi_ok */; + } + return 9 /* napi_status.napi_generic_failure */; + }, + callComplete: function (work, status) { + var complete = emnapiAWMT.getComplete(work); + var env = emnapiAWMT.getEnv(work); + var data = emnapiAWMT.getData(work); + var envObject = emnapiCtx.envStore.get(env); + var scope = emnapiCtx.openScope(envObject); + var callback = function () { + if (!complete) + return; + envObject.callbackIntoModule(true, function () { + (wasmTable.get(complete))(env, status, data); + }); + }; + try { + if (emnapiNodeBinding) { + var resource = emnapiAWMT.getResource(work); + var resource_value = emnapiCtx.refStore.get(resource).get(); + var resourceObject = emnapiCtx.handleStore.get(resource_value).value; + var view = new DataView(wasmMemory.buffer); + var asyncId = view.getFloat64(work + emnapiAWMT.offset.async_id, true); + var triggerAsyncId = view.getFloat64(work + emnapiAWMT.offset.trigger_async_id, true); + emnapiNodeBinding.node.makeCallback(resourceObject, callback, [], { + asyncId: asyncId, + triggerAsyncId: triggerAsyncId + }); + } + else { + callback(); + } + } + finally { + emnapiCtx.closeScope(envObject, scope); + } + } + }; + /** @__sig ippppppp */ + var napi_create_async_work = singleThreadAsyncWork + ? function (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); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, id, true); + return envObject.clearLastError(); + } + : function (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 sizeofAW = emnapiAWMT.offset.end; + var aw = _malloc(sizeofAW); + if (!aw) + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + new Uint8Array(wasmMemory.buffer).subarray(aw, aw + sizeofAW).fill(0); + var s = envObject.ensureHandleId(resourceObject); + var resourceRef = emnapiCtx.createReference(envObject, s, 1, 1 /* Ownership.kUserland */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var resource_ = resourceRef.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(aw, resource_, true); + _emnapi_node_emit_async_init(s, resource_name, -1, aw + emnapiAWMT.offset.async_id); + HEAP_DATA_VIEW.setInt32(aw + emnapiAWMT.offset.env, env, true); + HEAP_DATA_VIEW.setInt32(aw + emnapiAWMT.offset.execute, execute, true); + HEAP_DATA_VIEW.setInt32(aw + emnapiAWMT.offset.complete, complete, true); + HEAP_DATA_VIEW.setInt32(aw + emnapiAWMT.offset.data, data, true); + HEAP_DATA_VIEW.setInt32(result, aw, true); + return envObject.clearLastError(); + }; + /** @__sig ipp */ + var napi_delete_async_work = singleThreadAsyncWork + ? function (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(); + } + : function (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 */); + var resource = emnapiAWMT.getResource(work); + emnapiCtx.refStore.get(resource).dispose(); + if (emnapiNodeBinding) { + var view = new DataView(wasmMemory.buffer); + var asyncId = view.getFloat64(work + emnapiAWMT.offset.async_id, true); + var triggerAsyncId = view.getFloat64(work + emnapiAWMT.offset.trigger_async_id, true); + _emnapi_node_emit_async_destroy(asyncId, triggerAsyncId); + } + _free(work); + return envObject.clearLastError(); + }; + /** @__sig ipp */ + var napi_queue_async_work = singleThreadAsyncWork + ? function (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(); + } + : function (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 */); + emnapiAWMT.scheduleWork(work); + return envObject.clearLastError(); + }; + /** @__sig ipp */ + var napi_cancel_async_work = singleThreadAsyncWork + ? function (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); + } + : function (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 = emnapiAWMT.cancelWork(work); + if (status === 0 /* napi_status.napi_ok */) + return envObject.clearLastError(); + return envObject.setLastError(status); + }; + function initWorker(startArg) { + if (napiModule.childThread) { + if (typeof 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'); + } + wasmInstance.exports.emnapi_async_worker_init(startArg); + } + else { + throw new Error('startThread is only available in child threads'); + } + } + function executeAsyncWork(work) { + if (!ENVIRONMENT_IS_PTHREAD) + return; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var execute = emnapiAWMT.getExecute(work); + var env = emnapiAWMT.getEnv(work); + var data = emnapiAWMT.getData(work); + (wasmTable.get(execute))(env, data); + var postMessage = napiModule.postMessage; + postMessage({ + __emnapi__: { + type: 'async-work-complete', + payload: { work: work } + } + }); + } + napiModule.initWorker = initWorker; + napiModule.executeAsyncWork = executeAsyncWork; + var asyncWorkMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_cancel_async_work: napi_cancel_async_work, + napi_create_async_work: napi_create_async_work, + napi_delete_async_work: napi_delete_async_work, + napi_queue_async_work: napi_queue_async_work + }); + /** + * @__deps malloc + * @__deps free + * @__postset + * ``` + * emnapiExternalMemory.init(); + * ``` + */ + var emnapiExternalMemory = { + registry: typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(function (_pointer) { _free(_pointer); }) : undefined, + table: new WeakMap(), + wasmMemoryViewTable: new WeakMap(), + init: function () { + emnapiExternalMemory.registry = typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(function (_pointer) { _free(_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 /* Ownership.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 /* Ownership.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(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 /* Ownership.kRuntime */ : 1 /* Ownership.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 /* Ownership.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 /* Ownership.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 }; + } + }; + /* eslint-disable @typescript-eslint/indent */ + /** + * @__postset + * ``` + * emnapiString.init(); + * ``` + */ + var emnapiString = { + utf8Decoder: undefined, + utf16Decoder: undefined, + init: function () { + 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 ; + } + } + }; + var utf8Decoder; + utf8Decoder = typeof TextDecoder === 'function' ? new TextDecoder() : fallbackDecoder; + emnapiString.utf8Decoder = utf8Decoder; + 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(''); + } + }; + var utf16Decoder; + utf16Decoder = typeof TextDecoder === 'function' ? new TextDecoder('utf-16le') : fallbackDecoder2; + 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); + } + 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; + } + return emnapiString.utf8Decoder.decode(((typeof SharedArrayBuffer === "function" && HEAPU8.buffer instanceof SharedArrayBuffer) || (Object.prototype.toString.call(HEAPU8.buffer.constructor) === "[object SharedArrayBuffer]")) ? HEAPU8.slice(ptr, end) : HEAPU8.subarray(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; + } + length = end - ptr; + if (length <= 32) { + return String.fromCharCode.apply(null, new Uint16Array(wasmMemory.buffer, ptr, length / 2)); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var HEAPU8 = new Uint8Array(wasmMemory.buffer); + return emnapiString.utf16Decoder.decode(((typeof SharedArrayBuffer === "function" && HEAPU8.buffer instanceof SharedArrayBuffer) || (Object.prototype.toString.call(HEAPU8.buffer.constructor) === "[object SharedArrayBuffer]")) ? HEAPU8.slice(ptr, end) : HEAPU8.subarray(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; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + for (var i = 0; i < numCharsToWrite; ++i) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var codeUnit = str.charCodeAt(i); + HEAP_DATA_VIEW.setInt16(outPtr, codeUnit, true); + outPtr += 2; + } + HEAP_DATA_VIEW.setInt16(outPtr, 0, true); + return outPtr - startPtr; + }, + newString: function (env, str, length, result, stringMaker) { + 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 strValue = stringMaker(str, autoLength, sizelength); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = emnapiCtx.addToCurrentScope(strValue).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + }, + newExternalString: function (env, str, length, finalize_callback, finalize_hint, result, copied, createApi, stringMaker) { + 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) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(copied, 1, true); + } + if (finalize_callback) { + envObject.callFinalizer(finalize_callback, str, finalize_hint); + } + } + return status; + } + }; + /** + * @__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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v = handle.value.length >>> 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setUint32(result, v, true); + 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 */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (data) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var p = emnapiExternalMemory.getArrayBufferPointer(handle.value, true).address; + HEAP_DATA_VIEW.setInt32(data, p, true); + } + if (byte_length) { + HEAP_DATA_VIEW.setUint32(byte_length, handle.value.byteLength, true); + } + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var p = envObject.ensureHandleId(Object.getPrototypeOf(v)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, p, true); + 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; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (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 */); + } + HEAP_DATA_VIEW.setInt32(type, t, true); + } + if (length) { + HEAP_DATA_VIEW.setUint32(length, v.length, true); + } + var buffer; + if (data || arraybuffer) { + buffer = v.buffer; + if (data) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var p = emnapiExternalMemory.getViewPointer(v, true).address; + HEAP_DATA_VIEW.setInt32(data, p, true); + } + if (arraybuffer) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var ab = envObject.ensureHandleId(buffer); + HEAP_DATA_VIEW.setInt32(arraybuffer, ab, true); + } + } + if (byte_offset) { + HEAP_DATA_VIEW.setUint32(byte_offset, v.byteOffset, true); + } + 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()) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + 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; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (byte_length) { + HEAP_DATA_VIEW.setUint32(byte_length, v.byteLength, true); + } + var buffer; + if (data || arraybuffer) { + buffer = v.buffer; + if (data) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var p = emnapiExternalMemory.getViewPointer(v, true).address; + HEAP_DATA_VIEW.setInt32(data, p, true); + } + if (arraybuffer) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var ab = envObject.ensureHandleId(buffer); + HEAP_DATA_VIEW.setInt32(arraybuffer, ab, true); + } + } + if (byte_offset) { + HEAP_DATA_VIEW.setUint32(byte_offset, v.byteOffset, true); + } + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + } + v = handle.value.valueOf(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setFloat64(result, v, true); + 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 */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = handle.value ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_double(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 !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = handle.value; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setFloat64(result, r, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_get_value_bigint_int64(env, value, result, lossless) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!emnapiCtx.feature.supportBigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!lossless) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var handle = emnapiCtx.handleStore.get(value); + var numberValue = handle.value; + if (typeof numberValue !== 'bigint') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if ((numberValue >= (BigInt(-1) * (BigInt(1) << BigInt(63)))) && (numberValue < (BigInt(1) << BigInt(63)))) { + HEAP_DATA_VIEW.setInt8(lossless, 1, true); + } + else { + HEAP_DATA_VIEW.setInt8(lossless, 0, true); + numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + if (numberValue >= (BigInt(1) << BigInt(63))) { + numberValue = numberValue - (BigInt(1) << BigInt(64)); + } + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var low = Number(numberValue & BigInt(0xffffffff)); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var high = Number(numberValue >> BigInt(32)); + HEAP_DATA_VIEW.setInt32(result, low, true); + HEAP_DATA_VIEW.setInt32(result + 4, high, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_get_value_bigint_uint64(env, value, result, lossless) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!emnapiCtx.feature.supportBigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!lossless) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var handle = emnapiCtx.handleStore.get(value); + var numberValue = handle.value; + if (typeof numberValue !== 'bigint') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if ((numberValue >= BigInt(0)) && (numberValue < (BigInt(1) << BigInt(64)))) { + HEAP_DATA_VIEW.setInt8(lossless, 1, true); + } + else { + HEAP_DATA_VIEW.setInt8(lossless, 0, true); + numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var low = Number(numberValue & BigInt(0xffffffff)); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var high = Number(numberValue >> BigInt(32)); + HEAP_DATA_VIEW.setUint32(result, low, true); + HEAP_DATA_VIEW.setUint32(result + 4, high, true); + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_bigint_words(env, value, sign_bit, word_count, words) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!emnapiCtx.feature.supportBigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!word_count) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var handle = emnapiCtx.handleStore.get(value); + if (!handle.isBigInt()) { + return envObject.setLastError(17 /* napi_status.napi_bigint_expected */); + } + var isMinus = handle.value < BigInt(0); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + var word_count_int = HEAP_DATA_VIEW.getUint32(word_count, true); + var wordCount = 0; + var bigintValue = isMinus ? (handle.value * BigInt(-1)) : handle.value; + while (bigintValue !== BigInt(0)) { + wordCount++; + bigintValue = bigintValue >> BigInt(64); + } + bigintValue = isMinus ? (handle.value * BigInt(-1)) : handle.value; + if (!sign_bit && !words) { + word_count_int = wordCount; + HEAP_DATA_VIEW.setUint32(word_count, word_count_int, true); + } + else { + if (!sign_bit) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!words) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var wordsArr = []; + while (bigintValue !== BigInt(0)) { + var uint64 = bigintValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + wordsArr.push(uint64); + bigintValue = bigintValue >> BigInt(64); + } + var len = Math.min(word_count_int, wordsArr.length); + for (var i = 0; i < len; i++) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var low = Number(wordsArr[i] & BigInt(0xffffffff)); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var high = Number(wordsArr[i] >> BigInt(32)); + HEAP_DATA_VIEW.setUint32(words + i * 8, low, true); + HEAP_DATA_VIEW.setUint32(words + i * 8 + 4, high, true); + } + HEAP_DATA_VIEW.setInt32(sign_bit, isMinus ? 1 : 0, true); + HEAP_DATA_VIEW.setUint32(word_count, len, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_external(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 (!handle.isExternal()) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var p = handle.data(envObject); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, p, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_int32(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 !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v = new Int32Array([handle.value])[0]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_int64(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 !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + var numberValue = handle.value; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (numberValue === Number.POSITIVE_INFINITY || numberValue === Number.NEGATIVE_INFINITY || isNaN(numberValue)) { + HEAP_DATA_VIEW.setInt32(result, 0, true); + HEAP_DATA_VIEW.setInt32(result + 4, 0, true); + } + else if (numberValue < /* INT64_RANGE_NEGATIVE */ -9223372036854776000) { + HEAP_DATA_VIEW.setInt32(result, 0, true); + HEAP_DATA_VIEW.setInt32(result + 4, 0x80000000, true); + } + else if (numberValue >= /* INT64_RANGE_POSITIVE */ 9223372036854776000) { + HEAP_DATA_VIEW.setUint32(result, 0xffffffff, true); + HEAP_DATA_VIEW.setUint32(result + 4, 0x7fffffff, true); + } + else { + $emnapiSetValueI64(result, Math.trunc(numberValue)); + } + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_string_latin1(env, value, buf, buf_size, 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 */); + buf_size = buf_size >>> 0; + var handle = emnapiCtx.handleStore.get(value); + if (typeof handle.value !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (!buf) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + HEAP_DATA_VIEW.setUint32(result, handle.value.length, true); + } + else if (buf_size !== 0) { + var copied = 0; + var v = void 0; + for (var i = 0; i < buf_size - 1; ++i) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + v = handle.value.charCodeAt(i) & 0xff; + HEAP_DATA_VIEW.setUint8(buf + i, v, true); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + copied++; + } + HEAP_DATA_VIEW.setUint8(buf + copied, 0, true); + if (result) { + HEAP_DATA_VIEW.setUint32(result, copied, true); + } + } + else if (result) { + HEAP_DATA_VIEW.setUint32(result, 0, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_string_utf8(env, value, buf, buf_size, 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 */); + buf_size = buf_size >>> 0; + var handle = emnapiCtx.handleStore.get(value); + if (typeof handle.value !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (!buf) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var strLength = emnapiString.lengthBytesUTF8(handle.value); + HEAP_DATA_VIEW.setUint32(result, strLength, true); + } + else if (buf_size !== 0) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var copied = emnapiString.stringToUTF8(handle.value, buf, buf_size); + if (result) { + HEAP_DATA_VIEW.setUint32(result, copied, true); + } + } + else if (result) { + HEAP_DATA_VIEW.setUint32(result, 0, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_string_utf16(env, value, buf, buf_size, 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 */); + buf_size = buf_size >>> 0; + var handle = emnapiCtx.handleStore.get(value); + if (typeof handle.value !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (!buf) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + HEAP_DATA_VIEW.setUint32(result, handle.value.length, true); + } + else if (buf_size !== 0) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var copied = emnapiString.stringToUTF16(handle.value, buf, buf_size * 2); + if (result) { + HEAP_DATA_VIEW.setUint32(result, copied / 2, true); + } + } + else if (result) { + HEAP_DATA_VIEW.setUint32(result, 0, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_uint32(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 !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v = new Uint32Array([handle.value])[0]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setUint32(result, v, true); + return envObject.clearLastError(); + } + var convert2cMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_get_array_length: napi_get_array_length, + napi_get_arraybuffer_info: napi_get_arraybuffer_info, + napi_get_buffer_info: napi_get_buffer_info, + napi_get_dataview_info: napi_get_dataview_info, + napi_get_date_value: napi_get_date_value, + napi_get_prototype: napi_get_prototype, + napi_get_typedarray_info: napi_get_typedarray_info, + napi_get_value_bigint_int64: napi_get_value_bigint_int64, + napi_get_value_bigint_uint64: napi_get_value_bigint_uint64, + napi_get_value_bigint_words: napi_get_value_bigint_words, + napi_get_value_bool: napi_get_value_bool, + napi_get_value_double: napi_get_value_double, + napi_get_value_external: napi_get_value_external, + napi_get_value_int32: napi_get_value_int32, + napi_get_value_int64: napi_get_value_int64, + napi_get_value_string_latin1: napi_get_value_string_latin1, + napi_get_value_string_utf16: napi_get_value_string_utf16, + napi_get_value_string_utf8: napi_get_value_string_utf8, + napi_get_value_uint32: napi_get_value_uint32 + }); + /** + * @__sig ipip + */ + function napi_create_int32(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v = emnapiCtx.addToCurrentScope(value).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ipip + */ + function napi_create_uint32(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v = emnapiCtx.addToCurrentScope(value >>> 0).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ipjp + */ + function napi_create_int64(env, low, high, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + var value; + if (!high) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + value = Number(low); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v1 = emnapiCtx.addToCurrentScope(value).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(high, v1, true); + return envObject.clearLastError(); + } + /** + * @__sig ipdp + */ + function napi_create_double(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v = emnapiCtx.addToCurrentScope(value).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_create_string_latin1(env, str, length, result) { + return emnapiString.newString(env, str, length, result, function (str, autoLength, sizeLength) { + var latin1String = ''; + var len = 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (autoLength) { + while (true) { + var ch = HEAP_DATA_VIEW.getUint8(str, true); + if (!ch) + break; + latin1String += String.fromCharCode(ch); + str++; + } + } + else { + while (len < sizeLength) { + var ch = HEAP_DATA_VIEW.getUint8(str, true); + if (!ch) + break; + latin1String += String.fromCharCode(ch); + len++; + str++; + } + } + return latin1String; + }); + } + /** + * @__sig ipppp + */ + function napi_create_string_utf16(env, str, length, result) { + return emnapiString.newString(env, str, length, result, function (str) { + return emnapiString.UTF16ToString(str, length); + }); + } + /** + * @__sig ipppp + */ + function napi_create_string_utf8(env, str, length, result) { + return emnapiString.newString(env, str, length, result, function (str) { + return emnapiString.UTF8ToString(str, length); + }); + } + /** + * @__sig ippppppp + */ + function node_api_create_external_string_latin1(env, str, length, finalize_callback, finalize_hint, result, copied) { + return emnapiString.newExternalString(env, str, length, finalize_callback, finalize_hint, result, copied, napi_create_string_latin1, undefined); + } + /** + * @__sig ippppppp + */ + function node_api_create_external_string_utf16(env, str, length, finalize_callback, finalize_hint, result, copied) { + return emnapiString.newExternalString(env, str, length, finalize_callback, finalize_hint, result, copied, napi_create_string_utf16, undefined); + } + /** + * @__sig ipppp + */ + function node_api_create_property_key_utf16(env, str, length, result) { + return napi_create_string_utf16(env, str, length, result); + } + /** + * @__sig ipjp + */ + function napi_create_bigint_int64(env, low, high, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!emnapiCtx.feature.supportBigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + var value; + if (!high) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + value = low; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v1 = emnapiCtx.addToCurrentScope(value).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(high, v1, true); + return envObject.clearLastError(); + } + /** + * @__sig ipjp + */ + function napi_create_bigint_uint64(env, low, high, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!emnapiCtx.feature.supportBigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + var value; + if (!high) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + value = low & ((BigInt(1) << BigInt(64)) - BigInt(1)); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v1 = emnapiCtx.addToCurrentScope(value).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(high, v1, true); + return envObject.clearLastError(); + } + /** + * @__sig ipippp + */ + function napi_create_bigint_words(env, sign_bit, word_count, words, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v, i; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!emnapiCtx.feature.supportBigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + word_count = word_count >>> 0; + if (word_count > 2147483647) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (word_count > (1024 * 1024 / (4 * 8) / 2)) { + throw new RangeError('Maximum BigInt size exceeded'); + } + var value = BigInt(0); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + for (i = 0; i < word_count; i++) { + var low = HEAP_DATA_VIEW.getUint32(words + i * 8, true); + var high = HEAP_DATA_VIEW.getUint32(words + i * 8 + 4, true); + var wordi = BigInt(low) | (BigInt(high) << BigInt(32)); + value += wordi << BigInt(64 * i); + } + value *= ((BigInt(sign_bit) % BigInt(2) === BigInt(0)) ? BigInt(1) : BigInt(-1)); + v = emnapiCtx.addToCurrentScope(value).id; + HEAP_DATA_VIEW.setInt32(result, v, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + var convert2napiMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_create_bigint_int64: napi_create_bigint_int64, + napi_create_bigint_uint64: napi_create_bigint_uint64, + napi_create_bigint_words: napi_create_bigint_words, + napi_create_double: napi_create_double, + napi_create_int32: napi_create_int32, + napi_create_int64: napi_create_int64, + napi_create_string_latin1: napi_create_string_latin1, + napi_create_string_utf16: napi_create_string_utf16, + napi_create_string_utf8: napi_create_string_utf8, + napi_create_uint32: napi_create_uint32, + node_api_create_external_string_latin1: node_api_create_external_string_latin1, + node_api_create_external_string_utf16: node_api_create_external_string_utf16, + node_api_create_property_key_utf16: node_api_create_property_key_utf16 + }); + function emnapiCreateFunction(envObject, utf8name, length, cb, data) { + var functionName = (!utf8name || !length) ? '' : (emnapiString.UTF8ToString(utf8name, length)); + var f; + var makeFunction = function () { + return function () { + var cbinfo = emnapiCtx.cbinfoStack.push(this, data, arguments, f); + var scope = emnapiCtx.openScope(envObject); + try { + return envObject.callIntoModule(function (envObject) { + var napiValue = (wasmTable.get(cb))(envObject.id, cbinfo); + return (!napiValue) ? undefined : emnapiCtx.handleStore.get(napiValue).value; + }); + } + finally { + emnapiCtx.cbinfoStack.pop(); + emnapiCtx.closeScope(envObject, scope); + } + }; + }; + if (functionName === '') { + f = makeFunction(); + return { status: 0 /* napi_status.napi_ok */, f: f }; + } + if (!(/^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(functionName))) { + return { status: 1 /* napi_status.napi_invalid_arg */, f: undefined }; + } + if (emnapiCtx.feature.supportNewFunction) { + var _ = makeFunction(); + try { + f = (new Function('_', 'return function ' + functionName + '(){' + + '"use strict";' + + 'return _.apply(this,arguments);' + + '};'))(_); + } + catch (_err) { + f = makeFunction(); + if (emnapiCtx.feature.canSetFunctionName) + Object.defineProperty(f, 'name', { value: functionName }); + } + } + else { + f = makeFunction(); + if (emnapiCtx.feature.canSetFunctionName) + Object.defineProperty(f, 'name', { value: functionName }); + } + return { status: 0 /* napi_status.napi_ok */, f: f }; + } + function emnapiDefineProperty(envObject, obj, propertyName, method, getter, setter, value, attributes, data) { + if (getter || setter) { + var localGetter = void 0; + var localSetter = void 0; + if (getter) { + localGetter = emnapiCreateFunction(envObject, 0, 0, getter, data).f; + } + if (setter) { + localSetter = emnapiCreateFunction(envObject, 0, 0, setter, data).f; + } + var desc = { + configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0, + enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0, + get: localGetter, + set: localSetter + }; + Object.defineProperty(obj, propertyName, desc); + } + else if (method) { + var localMethod = emnapiCreateFunction(envObject, 0, 0, method, data).f; + var desc = { + configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0, + enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0, + writable: (attributes & 1 /* napi_property_attributes.napi_writable */) !== 0, + value: localMethod + }; + Object.defineProperty(obj, propertyName, desc); + } + else { + var desc = { + configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0, + enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0, + writable: (attributes & 1 /* napi_property_attributes.napi_writable */) !== 0, + value: emnapiCtx.handleStore.get(value).value + }; + Object.defineProperty(obj, propertyName, desc); + } + } + function emnapiGetHandle(js_object) { + var handle = emnapiCtx.handleStore.get(js_object); + if (!(handle.isObject() || handle.isFunction())) { + return { status: 1 /* napi_status.napi_invalid_arg */ }; + } + if (typeof emnapiExternalMemory !== 'undefined' && ArrayBuffer.isView(handle.value)) { + if (emnapiExternalMemory.wasmMemoryViewTable.has(handle.value)) { + handle = emnapiCtx.addToCurrentScope(emnapiExternalMemory.wasmMemoryViewTable.get(handle.value)); + } + } + return { status: 0 /* napi_status.napi_ok */, handle: handle }; + } + function emnapiWrap(env, js_object, native_object, finalize_cb, finalize_hint, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var referenceId; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!emnapiCtx.feature.supportFinalizer) { + if (finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('napi_wrap', 'Parameter "finalize_cb" must be 0(NULL)'); + } + if (result) { + throw emnapiCtx.createNotSupportWeakRefError('napi_wrap', 'Parameter "result" must be 0(NULL)'); + } + } + if (!js_object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var handleResult = emnapiGetHandle(js_object); + if (handleResult.status !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(handleResult.status); + } + var handle = handleResult.handle; + if (envObject.getObjectBinding(handle.value).wrapped !== 0) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var reference = void 0; + if (result) { + if (!finalize_cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + reference = emnapiCtx.createReference(envObject, handle.id, 0, 1 /* Ownership.kUserland */, finalize_cb, native_object, finalize_hint); + referenceId = reference.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, referenceId, true); + } + else { + reference = emnapiCtx.createReference(envObject, handle.id, 0, 0 /* Ownership.kRuntime */, finalize_cb, native_object, !finalize_cb ? finalize_cb : finalize_hint); + } + envObject.getObjectBinding(handle.value).wrapped = reference.id; + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + function emnapiUnwrap(env, js_object, result, action) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var data; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!js_object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (action === 0 /* UnwrapAction.KeepWrap */) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var value = emnapiCtx.handleStore.get(js_object); + if (!(value.isObject() || value.isFunction())) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var binding = envObject.getObjectBinding(value.value); + var referenceId = binding.wrapped; + var ref = emnapiCtx.refStore.get(referenceId); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + data = ref.data(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, data, true); + } + if (action === 1 /* UnwrapAction.RemoveWrap */) { + binding.wrapped = 0; + if (ref.ownership() === 1 /* Ownership.kUserland */) { + // When the wrap is been removed, the finalizer should be reset. + ref.resetFinalizer(); + } + else { + ref.dispose(); + } + } + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppppp + */ + function napi_define_class(env, utf8name, length, constructor, callback_data, property_count, properties, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var propPtr, valueHandleId, attributes; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + if (!constructor) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + property_count = property_count >>> 0; + if (property_count > 0) { + if (!properties) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if ((length < -1) || (length > 2147483647) || (!utf8name)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var fresult = emnapiCreateFunction(envObject, utf8name, length, constructor, callback_data); + if (fresult.status !== 0 /* napi_status.napi_ok */) + return envObject.setLastError(fresult.status); + var F = fresult.f; + var propertyName = void 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + for (var i = 0; i < property_count; i++) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + propPtr = properties + (i * (4 * 8)); + var utf8Name = HEAP_DATA_VIEW.getInt32(propPtr, true); + var name_1 = HEAP_DATA_VIEW.getInt32(propPtr + 4, true); + var method = HEAP_DATA_VIEW.getInt32(propPtr + 8, true); + var getter = HEAP_DATA_VIEW.getInt32(propPtr + 12, true); + var setter = HEAP_DATA_VIEW.getInt32(propPtr + 16, true); + var value = HEAP_DATA_VIEW.getInt32(propPtr + 20, true); + attributes = HEAP_DATA_VIEW.getInt32(propPtr + 24, true); + var data = HEAP_DATA_VIEW.getInt32(propPtr + 28, true); + if (utf8Name) { + propertyName = emnapiString.UTF8ToString(utf8Name, -1); + } + else { + if (!name_1) { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + propertyName = emnapiCtx.handleStore.get(name_1).value; + if (typeof propertyName !== 'string' && typeof propertyName !== 'symbol') { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + } + if ((attributes & 1024 /* napi_property_attributes.napi_static */) !== 0) { + emnapiDefineProperty(envObject, F, propertyName, method, getter, setter, value, attributes, data); + continue; + } + emnapiDefineProperty(envObject, F.prototype, propertyName, method, getter, setter, value, attributes, data); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var valueHandle = emnapiCtx.addToCurrentScope(F); + valueHandleId = valueHandle.id; + HEAP_DATA_VIEW.setInt32(result, valueHandleId, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_wrap(env, js_object, native_object, finalize_cb, finalize_hint, result) { + return emnapiWrap(env, js_object, native_object, finalize_cb, finalize_hint, result); + } + /** + * @__sig ippp + */ + function napi_unwrap(env, js_object, result) { + return emnapiUnwrap(env, js_object, result, 0 /* UnwrapAction.KeepWrap */); + } + /** + * @__sig ippp + */ + function napi_remove_wrap(env, js_object, result) { + return emnapiUnwrap(env, js_object, result, 1 /* UnwrapAction.RemoveWrap */); + } + /** + * @__sig ippp + */ + function napi_type_tag_object(env, object, type_tag) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) { + return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + var value = emnapiCtx.handleStore.get(object); + if (!(value.isObject() || value.isFunction())) { + return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */); + } + if (!type_tag) { + return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + var binding = envObject.getObjectBinding(value.value); + if (binding.tag !== null) { + return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + var tag = new Uint8Array(16); + tag.set(new Uint8Array(wasmMemory.buffer, type_tag, 16)); + binding.tag = new Uint32Array(tag.buffer); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppp + */ + function napi_check_object_type_tag(env, object, type_tag, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars, one-var + var ret = true; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) { + return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + var value = emnapiCtx.handleStore.get(object); + if (!(value.isObject() || value.isFunction())) { + return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */); + } + if (!type_tag) { + return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + if (!result) { + return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + var binding = envObject.getObjectBinding(value.value); + if (binding.tag !== null) { + var tag = binding.tag; + var typeTag = new Uint32Array(wasmMemory.buffer, type_tag, 4); + ret = (tag[0] === typeTag[0] && + tag[1] === typeTag[1] && + tag[2] === typeTag[2] && + tag[3] === typeTag[3]); + } + else { + ret = false; + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, ret ? 1 : 0, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_add_finalizer(env, js_object, finalize_data, finalize_cb, finalize_hint, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!emnapiCtx.feature.supportFinalizer) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!js_object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!finalize_cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var handleResult = emnapiGetHandle(js_object); + if (handleResult.status !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(handleResult.status); + } + var handle = handleResult.handle; + var ownership = !result ? 0 /* Ownership.kRuntime */ : 1 /* Ownership.kUserland */; + var reference = emnapiCtx.createReference(envObject, handle.id, 0, ownership, finalize_cb, finalize_data, finalize_hint); + if (result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var referenceId = reference.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, referenceId, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function node_api_post_finalizer(env, finalize_cb, finalize_data, finalize_hint) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + var envObject = emnapiCtx.envStore.get(env); + envObject.enqueueFinalizer(emnapiCtx.createTrackedFinalizer(envObject, finalize_cb, finalize_data, finalize_hint)); + return envObject.clearLastError(); + } + var wrapMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_add_finalizer: napi_add_finalizer, + napi_check_object_type_tag: napi_check_object_type_tag, + napi_define_class: napi_define_class, + napi_remove_wrap: napi_remove_wrap, + napi_type_tag_object: napi_type_tag_object, + napi_unwrap: napi_unwrap, + napi_wrap: napi_wrap, + node_api_post_finalizer: node_api_post_finalizer + }); + /** + * @__sig ipippppp + */ + function emnapi_create_memory_view(env, typedarray_type, external_data, byte_length, finalize_cb, finalize_hint, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + byte_length = byte_length >>> 0; + if (!external_data) { + byte_length = 0; + } + if (byte_length > 2147483647) { + throw new RangeError('Cannot create a memory view larger than 2147483647 bytes'); + } + if ((external_data + byte_length) > wasmMemory.buffer.byteLength) { + throw new RangeError('Memory out of range'); + } + if (!emnapiCtx.feature.supportFinalizer && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('emnapi_create_memory_view', 'Parameter "finalize_cb" must be 0(NULL)'); + } + var viewDescriptor = void 0; + switch (typedarray_type) { + case 0 /* emnapi_memory_view_type.emnapi_int8_array */: + viewDescriptor = { Ctor: Int8Array, address: external_data, length: byte_length, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case 1 /* emnapi_memory_view_type.emnapi_uint8_array */: + viewDescriptor = { Ctor: Uint8Array, address: external_data, length: byte_length, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case 2 /* emnapi_memory_view_type.emnapi_uint8_clamped_array */: + viewDescriptor = { Ctor: Uint8ClampedArray, address: external_data, length: byte_length, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case 3 /* emnapi_memory_view_type.emnapi_int16_array */: + viewDescriptor = { Ctor: Int16Array, address: external_data, length: byte_length >> 1, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case 4 /* emnapi_memory_view_type.emnapi_uint16_array */: + viewDescriptor = { Ctor: Uint16Array, address: external_data, length: byte_length >> 1, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case 5 /* emnapi_memory_view_type.emnapi_int32_array */: + viewDescriptor = { Ctor: Int32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case 6 /* emnapi_memory_view_type.emnapi_uint32_array */: + viewDescriptor = { Ctor: Uint32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case 7 /* emnapi_memory_view_type.emnapi_float32_array */: + viewDescriptor = { Ctor: Float32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case 8 /* emnapi_memory_view_type.emnapi_float64_array */: + viewDescriptor = { Ctor: Float64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case 9 /* emnapi_memory_view_type.emnapi_bigint64_array */: + viewDescriptor = { Ctor: BigInt64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case 10 /* emnapi_memory_view_type.emnapi_biguint64_array */: + viewDescriptor = { Ctor: BigUint64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case -1 /* emnapi_memory_view_type.emnapi_data_view */: + viewDescriptor = { Ctor: DataView, address: external_data, length: byte_length, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + case -2 /* emnapi_memory_view_type.emnapi_buffer */: { + if (!emnapiCtx.feature.Buffer) { + throw emnapiCtx.createNotSupportBufferError('emnapi_create_memory_view', ''); + } + viewDescriptor = { Ctor: emnapiCtx.feature.Buffer, address: external_data, length: byte_length, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 }; + break; + } + default: return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var Ctor = viewDescriptor.Ctor; + var typedArray = typedarray_type === -2 /* emnapi_memory_view_type.emnapi_buffer */ + ? emnapiCtx.feature.Buffer.from(wasmMemory.buffer, viewDescriptor.address, viewDescriptor.length) + : new Ctor(wasmMemory.buffer, viewDescriptor.address, viewDescriptor.length); + var handle = emnapiCtx.addToCurrentScope(typedArray); + emnapiExternalMemory.wasmMemoryViewTable.set(typedArray, viewDescriptor); + if (finalize_cb) { + var status_1 = napi_add_finalizer(env, handle.id, external_data, finalize_cb, finalize_hint, /* NULL */ 0); + if (status_1 === 10 /* napi_status.napi_pending_exception */) { + var err = envObject.tryCatch.extractException(); + envObject.clearLastError(); + throw err; + } + else if (status_1 !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(status_1); + } + } + value = handle.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig i + */ + function emnapi_is_support_weakref() { + return emnapiCtx.feature.supportFinalizer ? 1 : 0; + } + /** + * @__sig i + */ + function emnapi_is_support_bigint() { + return emnapiCtx.feature.supportBigInt ? 1 : 0; + } + /** + * @__sig i + */ + function emnapi_is_node_binding_available() { + return emnapiNodeBinding ? 1 : 0; + } + function $emnapiSyncMemory(js_to_wasm, arrayBufferOrView, offset, len) { + offset = offset !== null && offset !== void 0 ? offset : 0; + offset = offset >>> 0; + var view; + if (arrayBufferOrView instanceof ArrayBuffer) { + var pointer = emnapiExternalMemory.getArrayBufferPointer(arrayBufferOrView, false).address; + if (!pointer) + throw new Error('Unknown ArrayBuffer address'); + if (typeof len !== 'number' || len === -1) { + len = arrayBufferOrView.byteLength - offset; + } + len = len >>> 0; + if (len === 0) + return arrayBufferOrView; + view = new Uint8Array(arrayBufferOrView, offset, len); + var wasmMemoryU8 = new Uint8Array(wasmMemory.buffer); + if (!js_to_wasm) { + view.set(wasmMemoryU8.subarray(pointer, pointer + len)); + } + else { + wasmMemoryU8.set(view, pointer); + } + return arrayBufferOrView; + } + if (ArrayBuffer.isView(arrayBufferOrView)) { + var viewPointerInfo = emnapiExternalMemory.getViewPointer(arrayBufferOrView, false); + var latestView = viewPointerInfo.view; + var pointer = viewPointerInfo.address; + if (!pointer) + throw new Error('Unknown ArrayBuffer address'); + if (typeof len !== 'number' || len === -1) { + len = latestView.byteLength - offset; + } + len = len >>> 0; + if (len === 0) + return latestView; + view = new Uint8Array(latestView.buffer, latestView.byteOffset + offset, len); + var wasmMemoryU8 = new Uint8Array(wasmMemory.buffer); + if (!js_to_wasm) { + view.set(wasmMemoryU8.subarray(pointer, pointer + len)); + } + else { + wasmMemoryU8.set(view, pointer); + } + return latestView; + } + throw new TypeError('emnapiSyncMemory expect ArrayBuffer or ArrayBufferView as first parameter'); + } + /** + * @__sig ipippp + */ + function emnapi_sync_memory(env, js_to_wasm, arraybuffer_or_view, offset, len) { + // 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer_or_view) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + var handleId = HEAP_DATA_VIEW.getInt32(arraybuffer_or_view, true); + var handle = envObject.ctx.handleStore.get(handleId); + if (!handle.isArrayBuffer() && !handle.isTypedArray() && !handle.isDataView()) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var ret = $emnapiSyncMemory(Boolean(js_to_wasm), handle.value, offset, len); + if (handle.value !== ret) { + v = envObject.ensureHandleId(ret); + HEAP_DATA_VIEW.setInt32(arraybuffer_or_view, v, true); + } + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + function $emnapiGetMemoryAddress(arrayBufferOrView) { + var isArrayBuffer = arrayBufferOrView instanceof ArrayBuffer; + var isDataView = arrayBufferOrView instanceof DataView; + var isTypedArray = ArrayBuffer.isView(arrayBufferOrView) && !isDataView; + if (!isArrayBuffer && !isTypedArray && !isDataView) { + throw new TypeError('emnapiGetMemoryAddress expect ArrayBuffer or ArrayBufferView as first parameter'); + } + var info; + if (isArrayBuffer) { + info = emnapiExternalMemory.getArrayBufferPointer(arrayBufferOrView, false); + } + else { + info = emnapiExternalMemory.getViewPointer(arrayBufferOrView, false); + } + return { + address: info.address, + ownership: info.ownership, + runtimeAllocated: info.runtimeAllocated + }; + } + /** + * @__sig ipppp + */ + function emnapi_get_memory_address(env, arraybuffer_or_view, address, ownership, runtime_allocated) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var p, runtimeAllocated, ownershipOut; + var info; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer_or_view) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!address && !ownership && !runtime_allocated) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var handle = envObject.ctx.handleStore.get(arraybuffer_or_view); + info = $emnapiGetMemoryAddress(handle.value); + p = info.address; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (address) { + HEAP_DATA_VIEW.setInt32(address, p, true); + } + if (ownership) { + ownershipOut = info.ownership; + HEAP_DATA_VIEW.setInt32(ownership, ownershipOut, true); + } + if (runtime_allocated) { + runtimeAllocated = info.runtimeAllocated; + HEAP_DATA_VIEW.setInt8(runtime_allocated, runtimeAllocated, true); + } + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipp + */ + function emnapi_get_runtime_version(env, version) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + var envObject = emnapiCtx.envStore.get(env); + if (!version) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var runtimeVersion; + try { + runtimeVersion = emnapiCtx.getRuntimeVersions().version; + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var versions = runtimeVersion.split('.') + .map(function (n) { return Number(n); }); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setUint32(version, versions[0], true); + HEAP_DATA_VIEW.setUint32(version + 4, versions[1], true); + HEAP_DATA_VIEW.setUint32(version + 8, versions[2], true); + return envObject.clearLastError(); + } + var emnapiMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + $emnapiGetMemoryAddress: $emnapiGetMemoryAddress, + $emnapiSyncMemory: $emnapiSyncMemory, + emnapi_create_memory_view: emnapi_create_memory_view, + emnapi_get_memory_address: emnapi_get_memory_address, + emnapi_get_runtime_version: emnapi_get_runtime_version, + emnapi_is_node_binding_available: emnapi_is_node_binding_available, + emnapi_is_support_bigint: emnapi_is_support_bigint, + emnapi_is_support_weakref: emnapi_is_support_weakref, + emnapi_sync_memory: emnapi_sync_memory + }); + /** + * @__sig ipp + */ + function napi_create_array(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = emnapiCtx.addToCurrentScope([]).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_create_array_with_length(env, length, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + length = length >>> 0; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = emnapiCtx.addToCurrentScope(new Array(length)).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + function emnapiCreateArrayBuffer(byte_length, data) { + byte_length = byte_length >>> 0; + var arrayBuffer = new ArrayBuffer(byte_length); + if (data) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var p = emnapiExternalMemory.getArrayBufferPointer(arrayBuffer, true).address; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(data, p, true); + } + return arrayBuffer; + } + /** + * @__sig ipppp + */ + function napi_create_arraybuffer(env, byte_length, data, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + var arrayBuffer = emnapiCreateArrayBuffer(byte_length, data); + value = emnapiCtx.addToCurrentScope(arrayBuffer).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipdp + */ + function napi_create_date(env, time, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + value = emnapiCtx.addToCurrentScope(new Date(time)).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippppp + */ + function napi_create_external(env, data, finalize_cb, finalize_hint, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + if (!emnapiCtx.feature.supportFinalizer && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('napi_create_external', 'Parameter "finalize_cb" must be 0(NULL)'); + } + var externalHandle = emnapiCtx.getCurrentScope().addExternal(envObject, data); + if (finalize_cb) { + emnapiCtx.createReference(envObject, externalHandle.id, 0, 0 /* Ownership.kRuntime */, finalize_cb, data, finalize_hint); + } + value = externalHandle.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_create_external_arraybuffer(env, external_data, byte_length, finalize_cb, finalize_hint, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + byte_length = byte_length >>> 0; + if (!external_data) { + byte_length = 0; + } + if ((external_data + byte_length) > wasmMemory.buffer.byteLength) { + throw new RangeError('Memory out of range'); + } + if (!emnapiCtx.feature.supportFinalizer && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('napi_create_external_arraybuffer', 'Parameter "finalize_cb" must be 0(NULL)'); + } + var arrayBuffer = new ArrayBuffer(byte_length); + if (byte_length === 0) { + try { + var MessageChannel_1 = emnapiCtx.feature.MessageChannel; + var messageChannel = new MessageChannel_1(); + messageChannel.port1.postMessage(arrayBuffer, [arrayBuffer]); + } + catch (_) { } + } + else { + var u8arr = new Uint8Array(arrayBuffer); + u8arr.set(new Uint8Array(wasmMemory.buffer).subarray(external_data, external_data + byte_length)); + emnapiExternalMemory.table.set(arrayBuffer, { + address: external_data, + ownership: 1 /* Ownership.kUserland */, + runtimeAllocated: 0 + }); + } + var handle = emnapiCtx.addToCurrentScope(arrayBuffer); + if (finalize_cb) { + var status_1 = napi_add_finalizer(env, handle.id, external_data, finalize_cb, finalize_hint, /* NULL */ 0); + if (status_1 === 10 /* napi_status.napi_pending_exception */) { + var err = envObject.tryCatch.extractException(); + envObject.clearLastError(); + throw err; + } + else if (status_1 !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(status_1); + } + } + value = handle.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipp + */ + function napi_create_object(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = emnapiCtx.addToCurrentScope({}).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_create_symbol(env, description, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (!description) { + // eslint-disable-next-line symbol-description, @typescript-eslint/no-unused-vars + var value = emnapiCtx.addToCurrentScope(Symbol()).id; + HEAP_DATA_VIEW.setInt32(result, value, true); + } + else { + var handle = emnapiCtx.handleStore.get(description); + var desc = handle.value; + if (typeof desc !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v = emnapiCtx.addToCurrentScope(Symbol(desc)).id; + HEAP_DATA_VIEW.setInt32(result, v, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ipipppp + */ + function napi_create_typedarray(env, type, length, arraybuffer, byte_offset, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + 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(arraybuffer); + var buffer = handle.value; + if (!(buffer instanceof ArrayBuffer)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var createTypedArray = function (envObject, Type, size_of_element, buffer, byte_offset, length) { + var _a; + byte_offset = byte_offset >>> 0; + length = length >>> 0; + if (size_of_element > 1) { + if ((byte_offset) % (size_of_element) !== 0) { + var err = new RangeError("start offset of ".concat((_a = Type.name) !== null && _a !== void 0 ? _a : '', " should be a multiple of ").concat(size_of_element)); + err.code = 'ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT'; + envObject.tryCatch.setError(err); + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + } + if (((length * size_of_element) + byte_offset) > buffer.byteLength) { + var err = new RangeError('Invalid typed array length'); + err.code = 'ERR_NAPI_INVALID_TYPEDARRAY_LENGTH'; + envObject.tryCatch.setError(err); + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + var out = new Type(buffer, byte_offset, length); + if (buffer === wasmMemory.buffer) { + if (!emnapiExternalMemory.wasmMemoryViewTable.has(out)) { + emnapiExternalMemory.wasmMemoryViewTable.set(out, { + Ctor: Type, + address: byte_offset, + length: length, + ownership: 1 /* Ownership.kUserland */, + runtimeAllocated: 0 + }); + } + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + value = emnapiCtx.addToCurrentScope(out).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + }; + switch (type) { + case 0 /* napi_typedarray_type.napi_int8_array */: + return createTypedArray(envObject, Int8Array, 1, buffer, byte_offset, length); + case 1 /* napi_typedarray_type.napi_uint8_array */: + return createTypedArray(envObject, Uint8Array, 1, buffer, byte_offset, length); + case 2 /* napi_typedarray_type.napi_uint8_clamped_array */: + return createTypedArray(envObject, Uint8ClampedArray, 1, buffer, byte_offset, length); + case 3 /* napi_typedarray_type.napi_int16_array */: + return createTypedArray(envObject, Int16Array, 2, buffer, byte_offset, length); + case 4 /* napi_typedarray_type.napi_uint16_array */: + return createTypedArray(envObject, Uint16Array, 2, buffer, byte_offset, length); + case 5 /* napi_typedarray_type.napi_int32_array */: + return createTypedArray(envObject, Int32Array, 4, buffer, byte_offset, length); + case 6 /* napi_typedarray_type.napi_uint32_array */: + return createTypedArray(envObject, Uint32Array, 4, buffer, byte_offset, length); + case 7 /* napi_typedarray_type.napi_float32_array */: + return createTypedArray(envObject, Float32Array, 4, buffer, byte_offset, length); + case 8 /* napi_typedarray_type.napi_float64_array */: + return createTypedArray(envObject, Float64Array, 8, buffer, byte_offset, length); + case 9 /* napi_typedarray_type.napi_bigint64_array */: + return createTypedArray(envObject, BigInt64Array, 8, buffer, byte_offset, length); + case 10 /* napi_typedarray_type.napi_biguint64_array */: + return createTypedArray(envObject, BigUint64Array, 8, buffer, byte_offset, length); + default: + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__deps malloc + * @__sig ippp + */ + function napi_create_buffer(env, size, data, result) { + var _a; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value, pointer; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + var Buffer = emnapiCtx.feature.Buffer; + if (!Buffer) { + throw emnapiCtx.createNotSupportBufferError('napi_create_buffer', ''); + } + var buffer = void 0; + size = size >>> 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (!data || (size === 0)) { + buffer = Buffer.alloc(size); + value = emnapiCtx.addToCurrentScope(buffer).id; + HEAP_DATA_VIEW.setInt32(result, value, true); + } + else { + pointer = _malloc(size); + if (!pointer) + throw new Error('Out of memory'); + new Uint8Array(wasmMemory.buffer).subarray(pointer, pointer + size).fill(0); + var buffer_1 = Buffer.from(wasmMemory.buffer, pointer, size); + var viewDescriptor = { + Ctor: Buffer, + address: pointer, + length: size, + ownership: emnapiExternalMemory.registry ? 0 /* Ownership.kRuntime */ : 1 /* Ownership.kUserland */, + runtimeAllocated: 1 + }; + emnapiExternalMemory.wasmMemoryViewTable.set(buffer_1, viewDescriptor); + (_a = emnapiExternalMemory.registry) === null || _a === void 0 ? void 0 : _a.register(viewDescriptor, pointer); + value = emnapiCtx.addToCurrentScope(buffer_1).id; + HEAP_DATA_VIEW.setInt32(result, value, true); + HEAP_DATA_VIEW.setInt32(data, pointer, true); + } + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippppp + */ + function napi_create_buffer_copy(env, length, data, result_data, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + var Buffer = emnapiCtx.feature.Buffer; + if (!Buffer) { + throw emnapiCtx.createNotSupportBufferError('napi_create_buffer_copy', ''); + } + var arrayBuffer = emnapiCreateArrayBuffer(length, result_data); + var buffer = Buffer.from(arrayBuffer); + buffer.set(new Uint8Array(wasmMemory.buffer).subarray(data, data + length)); + value = emnapiCtx.addToCurrentScope(buffer).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_create_external_buffer(env, length, data, finalize_cb, finalize_hint, result) { + return emnapi_create_memory_view(env, -2 /* emnapi_memory_view_type.emnapi_buffer */, data, length, finalize_cb, finalize_hint, result); + } + /** + * @__sig ippppp + */ + function napi_create_dataview(env, byte_length, arraybuffer, byte_offset, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_length = byte_length >>> 0; + byte_offset = byte_offset >>> 0; + var handle = emnapiCtx.handleStore.get(arraybuffer); + var buffer = handle.value; + if (!(buffer instanceof ArrayBuffer)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if ((byte_length + byte_offset) > buffer.byteLength) { + var err = new RangeError('byte_offset + byte_length should be less than or equal to the size in bytes of the array passed in'); + err.code = 'ERR_NAPI_INVALID_DATAVIEW_ARGS'; + throw err; + } + var dataview = new DataView(buffer, byte_offset, byte_length); + if (buffer === wasmMemory.buffer) { + if (!emnapiExternalMemory.wasmMemoryViewTable.has(dataview)) { + emnapiExternalMemory.wasmMemoryViewTable.set(dataview, { + Ctor: DataView, + address: byte_offset, + length: byte_length, + ownership: 1 /* Ownership.kUserland */, + runtimeAllocated: 0 + }); + } + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + value = emnapiCtx.addToCurrentScope(dataview).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppp + */ + function node_api_symbol_for(env, utf8description, length, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var autoLength = length === -1; + var sizelength = length >>> 0; + if (length !== 0) { + if (!utf8description) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!(autoLength || (sizelength <= 2147483647))) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var descriptionString = emnapiString.UTF8ToString(utf8description, length); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = emnapiCtx.addToCurrentScope(Symbol.for(descriptionString)).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + var createMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_create_array: napi_create_array, + napi_create_array_with_length: napi_create_array_with_length, + napi_create_arraybuffer: napi_create_arraybuffer, + napi_create_buffer: napi_create_buffer, + napi_create_buffer_copy: napi_create_buffer_copy, + napi_create_dataview: napi_create_dataview, + napi_create_date: napi_create_date, + napi_create_external: napi_create_external, + napi_create_external_arraybuffer: napi_create_external_arraybuffer, + napi_create_external_buffer: napi_create_external_buffer, + napi_create_object: napi_create_object, + napi_create_symbol: napi_create_symbol, + napi_create_typedarray: napi_create_typedarray, + node_api_symbol_for: node_api_symbol_for + }); + /** @__sig ipip */ + function napi_get_boolean(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v = value === 0 ? 3 /* GlobalHandle.FALSE */ : 4 /* GlobalHandle.TRUE */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, v, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_global(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = 5 /* GlobalHandle.GLOBAL */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_null(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = 2 /* GlobalHandle.NULL */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_undefined(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = 1 /* GlobalHandle.UNDEFINED */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + var globalMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_get_boolean: napi_get_boolean, + napi_get_global: napi_get_global, + napi_get_null: napi_get_null, + napi_get_undefined: napi_get_undefined + }); + /** @__sig ipppp */ + function napi_set_instance_data(env, data, finalize_cb, finalize_hint) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + var envObject = emnapiCtx.envStore.get(env); + envObject.setInstanceData(data, finalize_cb, finalize_hint); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_instance_data(env, data) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + var envObject = emnapiCtx.envStore.get(env); + if (!data) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = envObject.getInstanceData(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(data, value, true); + return envObject.clearLastError(); + } + var envMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_get_instance_data: napi_get_instance_data, + napi_set_instance_data: napi_set_instance_data + }); + /** @__sig vpppp */ + function _emnapi_get_last_error_info(env, error_code, engine_error_code, engine_reserved) { + var envObject = emnapiCtx.envStore.get(env); + var lastError = envObject.lastError; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var errorCode = lastError.errorCode; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var engineErrorCode = lastError.engineErrorCode >>> 0; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var engineReserved = lastError.engineReserved; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(error_code, errorCode, true); + HEAP_DATA_VIEW.setUint32(engine_error_code, engineErrorCode, true); + HEAP_DATA_VIEW.setInt32(engine_reserved, engineReserved, true); + } + /** @__sig ipp */ + function napi_throw(env, error) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!error) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + envObject.tryCatch.setError(emnapiCtx.handleStore.get(error).value); + return envObject.clearLastError(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_throw_error(env, code, msg) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var error = new Error(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.tryCatch.setError(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_throw_type_error(env, code, msg) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var error = new TypeError(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.tryCatch.setError(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_throw_range_error(env, code, msg) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var error = new RangeError(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.tryCatch.setError(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function node_api_throw_syntax_error(env, code, msg) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var error = new SyntaxError(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.tryCatch.setError(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_is_exception_pending(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = envObject.tryCatch.hasCaught(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r ? 1 : 0, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_create_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var msgValue = emnapiCtx.handleStore.get(msg).value; + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var error = new Error(msgValue); + if (code) { + var codeValue = emnapiCtx.handleStore.get(code).value; + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = emnapiCtx.addToCurrentScope(error).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_create_type_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var msgValue = emnapiCtx.handleStore.get(msg).value; + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var error = new TypeError(msgValue); + if (code) { + var codeValue = emnapiCtx.handleStore.get(code).value; + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = emnapiCtx.addToCurrentScope(error).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_create_range_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var msgValue = emnapiCtx.handleStore.get(msg).value; + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var error = new RangeError(msgValue); + if (code) { + var codeValue = emnapiCtx.handleStore.get(code).value; + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = emnapiCtx.addToCurrentScope(error).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function node_api_create_syntax_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var msgValue = emnapiCtx.handleStore.get(msg).value; + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var error = new SyntaxError(msgValue); + if (code) { + var codeValue = emnapiCtx.handleStore.get(code).value; + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = emnapiCtx.addToCurrentScope(error).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_and_clear_last_exception(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (!envObject.tryCatch.hasCaught()) { + HEAP_DATA_VIEW.setInt32(result, 1, true); // ID_UNDEFINED + return envObject.clearLastError(); + } + else { + var err = envObject.tryCatch.exception(); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = envObject.ensureHandleId(err); + HEAP_DATA_VIEW.setInt32(result, value, true); + envObject.tryCatch.reset(); + } + return envObject.clearLastError(); + } + /** @__sig vpppp */ + function napi_fatal_error(location, location_len, message, message_len) { + var locationStr = emnapiString.UTF8ToString(location, location_len); + var messageStr = emnapiString.UTF8ToString(message, message_len); + if (emnapiNodeBinding) { + emnapiNodeBinding.napi.fatalError(locationStr, messageStr); + } + else { + abort('FATAL ERROR: ' + locationStr + ' ' + messageStr); + } + } + /** @__sig ipp */ + function napi_fatal_exception(env, err) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!err) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var error = envObject.ctx.handleStore.get(err); + try { + envObject.triggerFatalException(error.value); + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + return envObject.clearLastError(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + var errorMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + _emnapi_get_last_error_info: _emnapi_get_last_error_info, + napi_create_error: napi_create_error, + napi_create_range_error: napi_create_range_error, + napi_create_type_error: napi_create_type_error, + napi_fatal_error: napi_fatal_error, + napi_fatal_exception: napi_fatal_exception, + napi_get_and_clear_last_exception: napi_get_and_clear_last_exception, + napi_is_exception_pending: napi_is_exception_pending, + napi_throw: napi_throw, + napi_throw_error: napi_throw_error, + napi_throw_range_error: napi_throw_range_error, + napi_throw_type_error: napi_throw_type_error, + node_api_create_syntax_error: node_api_create_syntax_error, + node_api_throw_syntax_error: node_api_throw_syntax_error + }); + /** @__sig ipppppp */ + function napi_create_function(env, utf8name, length, cb, data, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + if (!cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var fresult = emnapiCreateFunction(envObject, utf8name, length, cb, data); + if (fresult.status !== 0 /* napi_status.napi_ok */) + return envObject.setLastError(fresult.status); + var f = fresult.f; + var valueHandle = emnapiCtx.addToCurrentScope(f); + value = valueHandle.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppppp */ + function napi_get_cb_info(env, cbinfo, argc, argv, this_arg, data) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + var envObject = emnapiCtx.envStore.get(env); + if (!cbinfo) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var cbinfoValue = emnapiCtx.cbinfoStack.get(cbinfo); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (argv) { + if (!argc) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var argcValue = HEAP_DATA_VIEW.getUint32(argc, true); + var len = cbinfoValue.args.length; + var arrlen = argcValue < len ? argcValue : len; + var i = 0; + for (; i < arrlen; i++) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var argVal = envObject.ensureHandleId(cbinfoValue.args[i]); + HEAP_DATA_VIEW.setInt32(argv + i * 4, argVal, true); + } + if (i < argcValue) { + for (; i < argcValue; i++) { + HEAP_DATA_VIEW.setInt32(argv + i * 4, 1, true); + } + } + } + if (argc) { + HEAP_DATA_VIEW.setUint32(argc, cbinfoValue.args.length, true); + } + if (this_arg) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var v = envObject.ensureHandleId(cbinfoValue.thiz); + HEAP_DATA_VIEW.setInt32(this_arg, v, true); + } + if (data) { + HEAP_DATA_VIEW.setInt32(data, cbinfoValue.data, true); + } + return envObject.clearLastError(); + } + /** @__sig ipppppp */ + function napi_call_function(env, recv, func, argc, argv, result) { + var i = 0; + // 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!recv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + argc = argc >>> 0; + if (argc > 0) { + if (!argv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var v8recv = emnapiCtx.handleStore.get(recv).value; + if (!func) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var v8func = emnapiCtx.handleStore.get(func).value; + if (typeof v8func !== 'function') + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var args = []; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + for (; i < argc; i++) { + var argVal = HEAP_DATA_VIEW.getInt32(argv + i * 4, true); + args.push(emnapiCtx.handleStore.get(argVal).value); + } + var ret = v8func.apply(v8recv, args); + if (result) { + v = envObject.ensureHandleId(ret); + HEAP_DATA_VIEW.setInt32(result, v, true); + } + return envObject.clearLastError(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippppp */ + function napi_new_instance(env, constructor, argc, argv, result) { + var i; + // 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!constructor) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + argc = argc >>> 0; + if (argc > 0) { + if (!argv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var Ctor = emnapiCtx.handleStore.get(constructor).value; + if (typeof Ctor !== 'function') + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var ret = void 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (emnapiCtx.feature.supportReflect) { + var argList = Array(argc); + for (i = 0; i < argc; i++) { + var argVal = HEAP_DATA_VIEW.getInt32(argv + i * 4, true); + argList[i] = emnapiCtx.handleStore.get(argVal).value; + } + ret = Reflect.construct(Ctor, argList, Ctor); + } + else { + var args = Array(argc + 1); + args[0] = undefined; + for (i = 0; i < argc; i++) { + var argVal = HEAP_DATA_VIEW.getInt32(argv + i * 4, true); + args[i + 1] = emnapiCtx.handleStore.get(argVal).value; + } + var BoundCtor = Ctor.bind.apply(Ctor, args); + ret = new BoundCtor(); + } + if (result) { + v = envObject.ensureHandleId(ret); + HEAP_DATA_VIEW.setInt32(result, v, true); + } + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_get_new_target(env, cbinfo, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!cbinfo) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var cbinfoValue = emnapiCtx.cbinfoStack.get(cbinfo); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = cbinfoValue.getNewTarget(envObject); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + var functionMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_call_function: napi_call_function, + napi_create_function: napi_create_function, + napi_get_cb_info: napi_get_cb_info, + napi_get_new_target: napi_get_new_target, + napi_new_instance: napi_new_instance + }); + /** @__sig ipp */ + function napi_open_handle_scope(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var scope = emnapiCtx.openScope(envObject); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, scope.id, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_close_handle_scope(env, scope) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!scope) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if ((envObject.openHandleScopes === 0)) { + return 13 /* napi_status.napi_handle_scope_mismatch */; + } + emnapiCtx.closeScope(envObject); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_open_escapable_handle_scope(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var scope = emnapiCtx.openScope(envObject); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, scope.id, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_close_escapable_handle_scope(env, scope) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!scope) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if ((envObject.openHandleScopes === 0)) { + return 13 /* napi_status.napi_handle_scope_mismatch */; + } + emnapiCtx.closeScope(envObject); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_escape_handle(env, scope, escapee, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!scope) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!escapee) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var scopeObject = emnapiCtx.scopeStore.get(scope); + if (!scopeObject.escapeCalled()) { + var newHandle = scopeObject.escape(escapee); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var value = newHandle ? newHandle.id : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.clearLastError(); + } + return envObject.setLastError(12 /* napi_status.napi_escape_called_twice */); + } + /** @__sig ippip */ + function napi_create_reference(env, value, initial_refcount, 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 (envObject.moduleApiVersion !== 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */) { + if (!(handle.isObject() || handle.isFunction() || handle.isSymbol())) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var ref = emnapiCtx.createReference(envObject, handle.id, initial_refcount >>> 0, 1 /* Ownership.kUserland */); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, ref.id, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_delete_reference(env, ref) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + emnapiCtx.refStore.get(ref).dispose(); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_reference_ref(env, ref, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var count = emnapiCtx.refStore.get(ref).ref(); + if (result) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setUint32(result, count, true); + } + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_reference_unref(env, ref, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var reference = emnapiCtx.refStore.get(ref); + var refcount = reference.refCount(); + if (refcount === 0) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var count = reference.unref(); + if (result) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setUint32(result, count, true); + } + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_get_reference_value(env, ref, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + var envObject = emnapiCtx.envStore.get(env); + envObject.checkGCAccess(); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var reference = emnapiCtx.refStore.get(ref); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var handleId = reference.get(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, handleId, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_add_env_cleanup_hook(env, fun, arg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + var envObject = emnapiCtx.envStore.get(env); + if (!fun) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + emnapiCtx.addCleanupHook(envObject, fun, arg); + return 0 /* napi_status.napi_ok */; + } + /** @__sig ippp */ + function napi_remove_env_cleanup_hook(env, fun, arg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + var envObject = emnapiCtx.envStore.get(env); + if (!fun) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + emnapiCtx.removeCleanupHook(envObject, fun, arg); + return 0 /* napi_status.napi_ok */; + } + /** @__sig vp */ + function _emnapi_env_ref(env) { + var envObject = emnapiCtx.envStore.get(env); + envObject.ref(); + } + /** @__sig vp */ + function _emnapi_env_unref(env) { + var envObject = emnapiCtx.envStore.get(env); + envObject.unref(); + } + var lifeMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + _emnapi_env_ref: _emnapi_env_ref, + _emnapi_env_unref: _emnapi_env_unref, + napi_add_env_cleanup_hook: napi_add_env_cleanup_hook, + napi_close_escapable_handle_scope: napi_close_escapable_handle_scope, + napi_close_handle_scope: napi_close_handle_scope, + napi_create_reference: napi_create_reference, + napi_delete_reference: napi_delete_reference, + napi_escape_handle: napi_escape_handle, + napi_get_reference_value: napi_get_reference_value, + napi_open_escapable_handle_scope: napi_open_escapable_handle_scope, + napi_open_handle_scope: napi_open_handle_scope, + napi_reference_ref: napi_reference_ref, + napi_reference_unref: napi_reference_unref, + napi_remove_env_cleanup_hook: napi_remove_env_cleanup_hook + }); + /** @__sig ippi */ + function _emnapi_get_filename(env, buf, len) { + var envObject = emnapiCtx.envStore.get(env); + var filename = envObject.filename; + if (!buf) { + return emnapiString.lengthBytesUTF8(filename); + } + return emnapiString.stringToUTF8(filename, buf, len); + } + var miscellaneousMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + _emnapi_get_filename: _emnapi_get_filename + }); + /** @__sig ippp */ + function napi_create_promise(env, deferred, promise) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var deferredObjectId, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!deferred) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!promise) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + var p = new Promise(function (resolve, reject) { + var deferredObject = emnapiCtx.createDeferred({ resolve: resolve, reject: reject }); + deferredObjectId = deferredObject.id; + HEAP_DATA_VIEW.setInt32(deferred, deferredObjectId, true); + }); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + value = emnapiCtx.addToCurrentScope(p).id; + HEAP_DATA_VIEW.setInt32(promise, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_resolve_deferred(env, deferred, resolution) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!deferred) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!resolution) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var deferredObject = emnapiCtx.deferredStore.get(deferred); + deferredObject.resolve(emnapiCtx.handleStore.get(resolution).value); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_reject_deferred(env, deferred, resolution) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!deferred) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!resolution) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var deferredObject = emnapiCtx.deferredStore.get(deferred); + deferredObject.reject(emnapiCtx.handleStore.get(resolution).value); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_is_promise(env, value, is_promise) { + 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 (!is_promise) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(value); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = h.isPromise() ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(is_promise, r, true); + return envObject.clearLastError(); + } + var promiseMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_create_promise: napi_create_promise, + napi_is_promise: napi_is_promise, + napi_reject_deferred: napi_reject_deferred, + napi_resolve_deferred: napi_resolve_deferred + }); + /** @__sig ippiiip */ + function napi_get_all_property_names(env, object, key_mode, key_filter, key_conversion, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (h.value == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + var obj = void 0; + try { + obj = h.isObject() || h.isFunction() ? h.value : Object(h.value); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + if (key_mode !== 0 /* napi_key_collection_mode.napi_key_include_prototypes */ && key_mode !== 1 /* napi_key_collection_mode.napi_key_own_only */) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (key_conversion !== 0 /* napi_key_conversion.napi_key_keep_numbers */ && key_conversion !== 1 /* napi_key_conversion.napi_key_numbers_to_strings */) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var props = []; + var names = void 0; + var symbols = void 0; + var i = void 0; + var own = true; + var integerIndiceRegex = /^(0|[1-9][0-9]*)$/; + do { + names = Object.getOwnPropertyNames(obj); + symbols = Object.getOwnPropertySymbols(obj); + for (i = 0; i < names.length; i++) { + props.push({ + name: integerIndiceRegex.test(names[i]) ? Number(names[i]) : names[i], + desc: Object.getOwnPropertyDescriptor(obj, names[i]), + own: own + }); + } + for (i = 0; i < symbols.length; i++) { + props.push({ + name: symbols[i], + desc: Object.getOwnPropertyDescriptor(obj, symbols[i]), + own: own + }); + } + if (key_mode === 1 /* napi_key_collection_mode.napi_key_own_only */) { + break; + } + obj = Object.getPrototypeOf(obj); + own = false; + } while (obj); + var ret = []; + var addName = function (ret, name, key_filter, conversion_mode) { + if (ret.indexOf(name) !== -1) + return; + if (conversion_mode === 0 /* napi_key_conversion.napi_key_keep_numbers */) { + ret.push(name); + } + else if (conversion_mode === 1 /* napi_key_conversion.napi_key_numbers_to_strings */) { + var realName = typeof name === 'number' ? String(name) : name; + if (typeof realName === 'string') { + if (!(key_filter & 8 /* napi_key_filter.napi_key_skip_strings */)) { + ret.push(realName); + } + } + else { + ret.push(realName); + } + } + }; + for (i = 0; i < props.length; i++) { + var prop = props[i]; + var name_1 = prop.name; + var desc = prop.desc; + if (key_filter === 0 /* napi_key_filter.napi_key_all_properties */) { + addName(ret, name_1, key_filter, key_conversion); + } + else { + if (key_filter & 8 /* napi_key_filter.napi_key_skip_strings */ && typeof name_1 === 'string') { + continue; + } + if (key_filter & 16 /* napi_key_filter.napi_key_skip_symbols */ && typeof name_1 === 'symbol') { + continue; + } + var shouldAdd = true; + switch (key_filter & 7) { + case 1 /* napi_key_filter.napi_key_writable */: { + shouldAdd = Boolean(desc.writable); + break; + } + case 2 /* napi_key_filter.napi_key_enumerable */: { + shouldAdd = Boolean(desc.enumerable); + break; + } + case (1 /* napi_key_filter.napi_key_writable */ | 2 /* napi_key_filter.napi_key_enumerable */): { + shouldAdd = Boolean(desc.writable && desc.enumerable); + break; + } + case 4 /* napi_key_filter.napi_key_configurable */: { + shouldAdd = Boolean(desc.configurable); + break; + } + case (4 /* napi_key_filter.napi_key_configurable */ | 1 /* napi_key_filter.napi_key_writable */): { + shouldAdd = Boolean(desc.configurable && desc.writable); + break; + } + case (4 /* napi_key_filter.napi_key_configurable */ | 2 /* napi_key_filter.napi_key_enumerable */): { + shouldAdd = Boolean(desc.configurable && desc.enumerable); + break; + } + case (4 /* napi_key_filter.napi_key_configurable */ | 2 /* napi_key_filter.napi_key_enumerable */ | 1 /* napi_key_filter.napi_key_writable */): { + shouldAdd = Boolean(desc.configurable && desc.enumerable && desc.writable); + break; + } + } + if (shouldAdd) { + addName(ret, name_1, key_filter, key_conversion); + } + } + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + value = emnapiCtx.addToCurrentScope(ret).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_get_property_names(env, object, result) { + return napi_get_all_property_names(env, object, 0 /* napi_key_collection_mode.napi_key_include_prototypes */, 2 /* napi_key_filter.napi_key_enumerable */ | 16 /* napi_key_filter.napi_key_skip_symbols */, 1 /* napi_key_conversion.napi_key_numbers_to_strings */, result); + } + /** @__sig ipppp */ + function napi_set_property(env, object, key, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (!(h.isObject() || h.isFunction())) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + h.value[emnapiCtx.handleStore.get(key).value] = emnapiCtx.handleStore.get(value).value; + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_has_property(env, object, key, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (h.value == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + var v = void 0; + try { + v = h.isObject() || h.isFunction() ? h.value : Object(h.value); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + r = (emnapiCtx.handleStore.get(key).value in v) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_get_property(env, object, key, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (h.value == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + var v = void 0; + try { + v = h.isObject() || h.isFunction() ? h.value : Object(h.value); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + value = envObject.ensureHandleId(v[emnapiCtx.handleStore.get(key).value]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_delete_property(env, object, key, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (!(h.isObject() || h.isFunction())) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + var propertyKey = emnapiCtx.handleStore.get(key).value; + if (emnapiCtx.feature.supportReflect) { + r = Reflect.deleteProperty(h.value, propertyKey); + } + else { + try { + r = delete h.value[propertyKey]; + } + catch (_) { + r = false; + } + } + if (result) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r ? 1 : 0, true); + } + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_has_own_property(env, object, key, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (h.value == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + var v = void 0; + try { + v = h.isObject() || h.isFunction() ? h.value : Object(h.value); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + var prop = emnapiCtx.handleStore.get(key).value; + if (typeof prop !== 'string' && typeof prop !== 'symbol') { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + r = Object.prototype.hasOwnProperty.call(v, emnapiCtx.handleStore.get(key).value); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r ? 1 : 0, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_set_named_property(env, object, cname, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (!(h.isObject() || h.isFunction())) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + if (!cname) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + emnapiCtx.handleStore.get(object).value[emnapiString.UTF8ToString(cname, -1)] = emnapiCtx.handleStore.get(value).value; + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_has_named_property(env, object, utf8name, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!utf8name) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var h = emnapiCtx.handleStore.get(object); + if (h.value == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + var v = void 0; + try { + v = h.isObject() || h.isFunction() ? h.value : Object(h.value); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + r = emnapiString.UTF8ToString(utf8name, -1) in v; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r ? 1 : 0, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_get_named_property(env, object, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!utf8name) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var h = emnapiCtx.handleStore.get(object); + if (h.value == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + var v = void 0; + try { + v = h.isObject() || h.isFunction() ? h.value : Object(h.value); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + value = envObject.ensureHandleId(v[emnapiString.UTF8ToString(utf8name, -1)]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_set_element(env, object, index, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (!(h.isObject() || h.isFunction())) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + h.value[index >>> 0] = emnapiCtx.handleStore.get(value).value; + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_has_element(env, object, index, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (h.value == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + var v = void 0; + try { + v = h.isObject() || h.isFunction() ? h.value : Object(h.value); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + r = ((index >>> 0) in v) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_get_element(env, object, index, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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 */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (h.value == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + var v = void 0; + try { + v = h.isObject() || h.isFunction() ? h.value : Object(h.value); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + value = envObject.ensureHandleId(v[index >>> 0]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_delete_element(env, object, index, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + if (!(h.isObject() || h.isFunction())) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + if (emnapiCtx.feature.supportReflect) { + r = Reflect.deleteProperty(h.value, index >>> 0); + } + else { + try { + r = delete h.value[index >>> 0]; + } + catch (_) { + r = false; + } + } + if (result) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r ? 1 : 0, true); + } + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_define_properties(env, object, property_count, properties) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var propPtr, attributes; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + property_count = property_count >>> 0; + if (property_count > 0) { + if (!properties) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + var maybeObject = h.value; + if (!(h.isObject() || h.isFunction())) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + var propertyName = void 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + for (var i = 0; i < property_count; i++) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + propPtr = properties + (i * (4 * 8)); + var utf8Name = HEAP_DATA_VIEW.getInt32(propPtr, true); + var name_2 = HEAP_DATA_VIEW.getInt32(propPtr + 4, true); + var method = HEAP_DATA_VIEW.getInt32(propPtr + 8, true); + var getter = HEAP_DATA_VIEW.getInt32(propPtr + 12, true); + var setter = HEAP_DATA_VIEW.getInt32(propPtr + 16, true); + var value = HEAP_DATA_VIEW.getInt32(propPtr + 20, true); + attributes = HEAP_DATA_VIEW.getInt32(propPtr + 24, true); + var data = HEAP_DATA_VIEW.getInt32(propPtr + 28, true); + if (utf8Name) { + propertyName = emnapiString.UTF8ToString(utf8Name, -1); + } + else { + if (!name_2) { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + propertyName = emnapiCtx.handleStore.get(name_2).value; + if (typeof propertyName !== 'string' && typeof propertyName !== 'symbol') { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + } + emnapiDefineProperty(envObject, maybeObject, propertyName, method, getter, setter, value, attributes, data); + } + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_object_freeze(env, object) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + var maybeObject = h.value; + if (!(h.isObject() || h.isFunction())) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + Object.freeze(maybeObject); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_object_seal(env, object) { + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(object); + var maybeObject = h.value; + if (!(h.isObject() || h.isFunction())) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + Object.seal(maybeObject); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + var propertyMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_define_properties: napi_define_properties, + napi_delete_element: napi_delete_element, + napi_delete_property: napi_delete_property, + napi_get_all_property_names: napi_get_all_property_names, + napi_get_element: napi_get_element, + napi_get_named_property: napi_get_named_property, + napi_get_property: napi_get_property, + napi_get_property_names: napi_get_property_names, + napi_has_element: napi_has_element, + napi_has_named_property: napi_has_named_property, + napi_has_own_property: napi_has_own_property, + napi_has_property: napi_has_property, + napi_object_freeze: napi_object_freeze, + napi_object_seal: napi_object_seal, + napi_set_element: napi_set_element, + napi_set_named_property: napi_set_named_property, + napi_set_property: napi_set_property + }); + /** @__sig ippp */ + function napi_run_script(env, script, result) { + var status; + // 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!script) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var v8Script = emnapiCtx.handleStore.get(script); + if (!v8Script.isString()) { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var g = emnapiCtx.handleStore.get(5 /* GlobalHandle.GLOBAL */).value; + var ret = g.eval(v8Script.value); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + value = envObject.ensureHandleId(ret); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, value, true); + status = envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + return status; + } + var scriptMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_run_script: napi_run_script + }); + /** @__sig ippp */ + function napi_typeof(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 v = emnapiCtx.handleStore.get(value); + var r; + if (v.isNumber()) { + r = 3 /* napi_valuetype.napi_number */; + } + else if (v.isBigInt()) { + r = 9 /* napi_valuetype.napi_bigint */; + } + else if (v.isString()) { + r = 4 /* napi_valuetype.napi_string */; + } + else if (v.isFunction()) { + // This test has to come before IsObject because IsFunction + // implies IsObject + r = 7 /* napi_valuetype.napi_function */; + } + else if (v.isExternal()) { + // This test has to come before IsObject because IsExternal + // implies IsObject + r = 8 /* napi_valuetype.napi_external */; + } + else if (v.isObject()) { + r = 6 /* napi_valuetype.napi_object */; + } + else if (v.isBoolean()) { + r = 2 /* napi_valuetype.napi_boolean */; + } + else if (v.isUndefined()) { + r = 0 /* napi_valuetype.napi_undefined */; + } + else if (v.isSymbol()) { + r = 5 /* napi_valuetype.napi_symbol */; + } + else if (v.isNull()) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + r = 1 /* napi_valuetype.napi_null */; + } + else { + // Should not get here unless V8 has added some new kind of value. + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_coerce_to_bool(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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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); + v = handle.value ? 4 /* GlobalHandle.TRUE */ : 3 /* GlobalHandle.FALSE */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, v, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_coerce_to_number(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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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.isBigInt()) { + throw new TypeError('Cannot convert a BigInt value to a number'); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + v = emnapiCtx.addToCurrentScope(Number(handle.value)).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, v, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_coerce_to_object(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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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'); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + v = envObject.ensureHandleId(Object(handle.value)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, v, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_coerce_to_string(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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 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.isSymbol()) { + throw new TypeError('Cannot convert a Symbol value to a string'); + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + v = emnapiCtx.addToCurrentScope(String(handle.value)).id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt32(result, v, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_instanceof(env, object, constructor, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!constructor) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, 0, true); + var ctor = emnapiCtx.handleStore.get(constructor); + if (!ctor.isFunction()) { + return envObject.setLastError(5 /* napi_status.napi_function_expected */); + } + var val = emnapiCtx.handleStore.get(object).value; + var ret = val instanceof ctor.value; + r = ret ? 1 : 0; + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_is_array(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 h = emnapiCtx.handleStore.get(value); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = h.isArray() ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_arraybuffer(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 h = emnapiCtx.handleStore.get(value); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = h.isArrayBuffer() ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_date(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 h = emnapiCtx.handleStore.get(value); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = h.isDate() ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_error(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 val = emnapiCtx.handleStore.get(value).value; + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = (val instanceof Error) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_typedarray(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 h = emnapiCtx.handleStore.get(value); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = h.isTypedArray() ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_buffer(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 h = emnapiCtx.handleStore.get(value); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = h.isBuffer() ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_dataview(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 h = emnapiCtx.handleStore.get(value); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r = h.isDataView() ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_strict_equals(env, lhs, rhs, result) { + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var r; + 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!lhs) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!rhs) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var lv = emnapiCtx.handleStore.get(lhs).value; + var rv = emnapiCtx.handleStore.get(rhs).value; + r = (lv === rv) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setInt8(result, r, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_detach_arraybuffer(env, arraybuffer) { + 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 value = emnapiCtx.handleStore.get(arraybuffer).value; + if (!(value instanceof ArrayBuffer)) { + if (typeof SharedArrayBuffer === 'function' && (value instanceof SharedArrayBuffer)) { + return envObject.setLastError(20 /* napi_status.napi_detachable_arraybuffer_expected */); + } + return envObject.setLastError(19 /* napi_status.napi_arraybuffer_expected */); + } + try { + var MessageChannel_1 = emnapiCtx.feature.MessageChannel; + var messageChannel = new MessageChannel_1(); + messageChannel.port1.postMessage(value, [value]); + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_detached_arraybuffer(env, arraybuffer, 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 === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + var h = emnapiCtx.handleStore.get(arraybuffer); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + if (h.isArrayBuffer() && h.value.byteLength === 0) { + try { + // eslint-disable-next-line no-new + new Uint8Array(h.value); + } + catch (_) { + HEAP_DATA_VIEW.setInt8(result, 1, true); + return envObject.getReturnStatus(); + } + } + HEAP_DATA_VIEW.setInt8(result, 0, true); + return envObject.getReturnStatus(); + } + catch (err) { + envObject.tryCatch.setError(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + var valueOperationMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_coerce_to_bool: napi_coerce_to_bool, + napi_coerce_to_number: napi_coerce_to_number, + napi_coerce_to_object: napi_coerce_to_object, + napi_coerce_to_string: napi_coerce_to_string, + napi_detach_arraybuffer: napi_detach_arraybuffer, + napi_instanceof: napi_instanceof, + napi_is_array: napi_is_array, + napi_is_arraybuffer: napi_is_arraybuffer, + napi_is_buffer: napi_is_buffer, + napi_is_dataview: napi_is_dataview, + napi_is_date: napi_is_date, + napi_is_detached_arraybuffer: napi_is_detached_arraybuffer, + napi_is_error: napi_is_error, + napi_is_typedarray: napi_is_typedarray, + napi_strict_equals: napi_strict_equals, + napi_typeof: napi_typeof + }); + /** @__sig ipp */ + function napi_get_version(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + var envObject = emnapiCtx.envStore.get(env); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // eslint-disable-next-line @typescript-eslint/no-unused-vars + var NODE_API_SUPPORTED_VERSION_MAX = 9 /* Version.NODE_API_SUPPORTED_VERSION_MAX */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer); + HEAP_DATA_VIEW.setUint32(result, NODE_API_SUPPORTED_VERSION_MAX, true); + return envObject.clearLastError(); + } + var versionMod = /*#__PURE__*/ Object.freeze({ + __proto__: null, + napi_get_version: napi_get_version + }); + emnapiAWST.init(); + emnapiExternalMemory.init(); + emnapiString.init(); + emnapiTSFN.init(); + napiModule.emnapi.syncMemory = $emnapiSyncMemory; + napiModule.emnapi.getMemoryAddress = $emnapiGetMemoryAddress; + function addImports(mod) { + var keys = Object.keys(mod); + for (var i = 0; i < keys.length; ++i) { + var k = keys[i]; + if (k.indexOf('$') === 0) + continue; + if (k.indexOf('emnapi_') === 0) { + napiModule.imports.emnapi[k] = mod[k]; + } + else if (k.indexOf('_emnapi_') === 0 || k === 'napi_set_last_error' || k === 'napi_clear_last_error') { + napiModule.imports.env[k] = mod[k]; + } + else { + napiModule.imports.napi[k] = mod[k]; + } + } + } + addImports(asyncMod); + addImports(memoryMod); + addImports(asyncWorkMod); + addImports(utilMod); + addImports(convert2cMod); + addImports(convert2napiMod); + addImports(createMod); + addImports(globalMod); + addImports(wrapMod); + addImports(envMod); + addImports(emnapiMod); + addImports(errorMod); + addImports(functionMod); + addImports(lifeMod); + addImports(miscellaneousMod); + addImports(nodeMod); + addImports(promiseMod); + addImports(propertyMod); + addImports(scriptMod); + addImports(valueOperationMod); + addImports(versionMod); + napiModule.imports.napi.napi_create_threadsafe_function = napi_create_threadsafe_function; + napiModule.imports.napi.napi_get_threadsafe_function_context = napi_get_threadsafe_function_context; + napiModule.imports.napi.napi_call_threadsafe_function = napi_call_threadsafe_function; + napiModule.imports.napi.napi_acquire_threadsafe_function = napi_acquire_threadsafe_function; + napiModule.imports.napi.napi_release_threadsafe_function = napi_release_threadsafe_function; + napiModule.imports.napi.napi_unref_threadsafe_function = napi_unref_threadsafe_function; + napiModule.imports.napi.napi_ref_threadsafe_function = napi_ref_threadsafe_function; + return napiModule; + })(); + return napiModule; +} + +function loadNapiModuleImpl(loadFn, userNapiModule, wasmInput, options) { + // eslint-disable-next-line @typescript-eslint/consistent-type-assertions + options = options !== null && options !== void 0 ? options : {}; + var getMemory = options.getMemory; + var getTable = options.getTable; + var beforeInit = options.beforeInit; + if (getMemory != null && typeof getMemory !== 'function') { + throw new TypeError('options.getMemory is not a function'); + } + if (getTable != null && typeof getTable !== 'function') { + throw new TypeError('options.getTable is not a function'); + } + if (beforeInit != null && typeof beforeInit !== 'function') { + throw new TypeError('options.beforeInit is not a function'); + } + var napiModule; + { + napiModule = createNapiModule(options); + } + var wasi = options.wasi; + var importObject = { + env: napiModule.imports.env, + napi: napiModule.imports.napi, + emnapi: napiModule.imports.emnapi, + wasi: { + // eslint-disable-next-line camelcase + 'thread-spawn': function __imported_wasi_thread_spawn(startArg, errorOrTid) { + return napiModule.spawnThread(startArg, errorOrTid); + } + } + }; + if (wasi) { + Object.assign(importObject, typeof wasi.getImportObject === 'function' + ? wasi.getImportObject() + : { wasi_snapshot_preview1: wasi.wasiImport }); + } + var overwriteImports = options.overwriteImports; + if (typeof overwriteImports === 'function') { + var newImportObject = overwriteImports(importObject); + if (typeof newImportObject === 'object' && newImportObject !== null) { + importObject = newImportObject; + } + } + return loadFn(wasmInput, importObject, function (err, source) { + if (err) { + throw err; + } + var originalInstance = source.instance; + var instance = originalInstance; + var originalExports = originalInstance.exports; + var exportMemory = 'memory' in originalExports; + var importMemory = 'memory' in importObject.env; + var memory = getMemory + ? getMemory(originalExports) + : exportMemory + ? originalExports.memory + : importMemory + ? importObject.env.memory + : undefined; + if (!memory) { + throw new Error('memory is neither exported nor imported'); + } + var table = getTable ? getTable(originalExports) : originalExports.__indirect_function_table; + if (wasi && !exportMemory) { + var exports_1 = Object.create(null); + Object.assign(exports_1, originalExports, { memory: memory }); + instance = { exports: exports_1 }; + } + var module = source.module; + if (wasi) { + if (napiModule.childThread) { + // https://github.com/nodejs/help/issues/4102 + var createHandler = function (target) { + var handlers = [ + 'apply', + 'construct', + 'defineProperty', + 'deleteProperty', + 'get', + 'getOwnPropertyDescriptor', + 'getPrototypeOf', + 'has', + 'isExtensible', + 'ownKeys', + 'preventExtensions', + 'set', + 'setPrototypeOf' + ]; + var handler = {}; + var _loop_1 = function (i) { + var name_1 = handlers[i]; + handler[name_1] = function () { + var args = Array.prototype.slice.call(arguments, 1); + args.unshift(target); + return Reflect[name_1].apply(Reflect, args); + }; + }; + for (var i = 0; i < handlers.length; i++) { + _loop_1(i); + } + return handler; + }; + var handler = createHandler(originalExports); + var noop_1 = function () { }; + handler.get = function (_target, p, receiver) { + if (p === 'memory') { + return memory; + } + if (p === '_initialize') { + return noop_1; + } + return Reflect.get(originalExports, p, receiver); + }; + var exportsProxy_1 = new Proxy(Object.create(null), handler); + instance = new Proxy(instance, { + get: function (target, p, receiver) { + if (p === 'exports') { + return exportsProxy_1; + } + return Reflect.get(target, p, receiver); + } + }); + } + wasi.initialize(instance); + } + if (beforeInit) { + beforeInit({ + instance: originalInstance, + module: module + }); + } + napiModule.init({ + instance: instance, + module: module, + memory: memory, + table: table + }); + var ret = { instance: originalInstance, module: module }; + { + ret.napiModule = napiModule; + } + return ret; + }); +} +function loadCallback(wasmInput, importObject, callback) { + return load(wasmInput, importObject).then(function (source) { + return callback(null, source); + }, function (err) { + return callback(err); + }); +} +function loadSyncCallback(wasmInput, importObject, callback) { + var source; + try { + source = loadSync(wasmInput, importObject); + } + catch (err) { + return callback(err); + } + return callback(null, source); +} +/** @public */ +function instantiateNapiModule( +/** Only support `BufferSource` or `WebAssembly.Module` on Node.js */ +wasmInput, options) { + return loadNapiModuleImpl(loadCallback, undefined, wasmInput, options); +} +/** @public */ +function instantiateNapiModuleSync(wasmInput, options) { + return loadNapiModuleImpl(loadSyncCallback, undefined, wasmInput, options); +} + +/** @public */ +var MessageHandler = /*#__PURE__*/ (function () { + function MessageHandler(options) { + var onLoad = options.onLoad; + if (typeof onLoad !== 'function') { + throw new TypeError('options.onLoad is not a function'); + } + this.onLoad = onLoad; + this.instance = undefined; + // this.module = undefined + this.napiModule = undefined; + this.messagesBeforeLoad = []; + } + MessageHandler.prototype.handle = function (e) { + var _this = this; + var _a; + if ((_a = e === null || e === void 0 ? void 0 : e.data) === null || _a === void 0 ? void 0 : _a.__emnapi__) { + var type = e.data.__emnapi__.type; + var payload_1 = e.data.__emnapi__.payload; + var onLoad = this.onLoad; + if (type === 'load') { + if (this.instance !== undefined) + return; + var source = onLoad(payload_1); + var then = source && 'then' in source ? source.then : undefined; + if (typeof then === 'function') { + // eslint-disable-next-line @typescript-eslint/no-floating-promises + then.call(source, function (source) { onLoaded.call(_this, source); }, function (err) { throw err; }); + } + else { + onLoaded.call(this, source); + } + } + else if (type === 'start') { + handleAfterLoad.call(this, e, function () { + _this.napiModule.startThread(payload_1.tid, payload_1.arg); + }); + } + else if (type === 'async-worker-init') { + handleAfterLoad.call(this, e, function () { + _this.napiModule.initWorker(payload_1.arg); + }); + } + else if (type === 'async-work-execute') { + handleAfterLoad.call(this, e, function () { + _this.napiModule.executeAsyncWork(payload_1.work); + }); + } + } + }; + return MessageHandler; +}()); +function handleAfterLoad(e, f) { + if (this.instance !== undefined) { + f.call(this, e); + } + else { + this.messagesBeforeLoad.push(e.data); + } +} +function onLoaded(source) { + if (source == null) { + throw new TypeError('onLoad should return an object'); + } + var instance = source.instance; + var napiModule = source.napiModule; + if (!instance) + throw new TypeError('onLoad should return an object which includes "instance"'); + if (!napiModule) + throw new TypeError('onLoad should return an object which includes "napiModule"'); + if (!napiModule.childThread) + throw new Error('napiModule should be created with `childThread: true`'); + this.instance = instance; + this.napiModule = napiModule; + var postMessage = napiModule.postMessage; + postMessage({ + __emnapi__: { + type: 'loaded', + payload: {} + } + }); + var messages = this.messagesBeforeLoad; + this.messagesBeforeLoad = []; + for (var i = 0; i < messages.length; i++) { + var data = messages[i]; + this.handle({ data: data }); + } +} + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise, SuppressedError, Symbol */ + +var extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); +}; + +function __extends(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +} + +typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}; + +var EMPTY_ARGS = []; +var CallbackInfo = /*#__PURE__*/ (function () { + function CallbackInfo(id, parent, child, thiz, data, args, fn) { + this.id = id; + this.parent = parent; + this.child = child; + this.thiz = thiz; + this.data = data; + this.args = args; + this.fn = fn; + } + CallbackInfo.prototype.getNewTarget = function (envObject) { + var thiz = this.thiz; + // eslint-disable-next-line @typescript-eslint/prefer-optional-chain + if (thiz == null || thiz.constructor == null) + return 0; + return thiz instanceof this.fn ? envObject.ensureHandleId(thiz.constructor) : 0; + }; + CallbackInfo.prototype.dispose = function () { + if (this.thiz !== undefined) + this.thiz = undefined; + this.args = EMPTY_ARGS; + this.fn = null; + }; + return CallbackInfo; +}()); +var ROOT_CBINFO = new CallbackInfo(0, null, null, null, 0, null, null); +var CallbackInfoStack = /*#__PURE__*/ (function () { + function CallbackInfoStack() { + this.current = ROOT_CBINFO; + } + CallbackInfoStack.prototype.get = function (id) { + if (id === 1) + return ROOT_CBINFO.child; + var info = ROOT_CBINFO; + for (var i = 0; i < id; ++i) { + info = info.child; + if (info === null) + return null; + } + return info === ROOT_CBINFO ? null : info; + }; + CallbackInfoStack.prototype.pop = function () { + var current = this.current; + if (current === ROOT_CBINFO) + return; + this.current = current.parent; + current.dispose(); + }; + CallbackInfoStack.prototype.push = function (thiz, data, args, fn) { + var info = this.current.child; + if (info) { + info.thiz = thiz; + info.data = data; + info.args = args; + info.fn = fn; + } + else { + info = new CallbackInfo(this.current.id + 1, this.current, null, thiz, data, args, fn); + this.current.child = info; + } + this.current = info; + return info.id; + }; + CallbackInfoStack.prototype.dispose = function () { + this.current = null; + }; + return CallbackInfoStack; +}()); + +var supportNewFunction = /*#__PURE__*/ (function () { + var f; + try { + f = new Function(); + } + catch (_) { + return false; + } + return typeof f === 'function'; +})(); +var _global = /*#__PURE__*/ (function () { + if (typeof globalThis !== 'undefined') + return globalThis; + var g = (function () { return this; })(); + if (!g && supportNewFunction) { + try { + g = new Function('return this')(); + } + catch (_) { } + } + if (!g) { + { + if (typeof global !== 'undefined') + return global; + } + if (typeof window !== 'undefined') + return window; + if (typeof self !== 'undefined') + return self; + } + return g; +})(); +var TryCatch = /*#__PURE__*/ (function () { + function TryCatch() { + this._exception = undefined; + this._caught = false; + } + TryCatch.prototype.isEmpty = function () { + return !this._caught; + }; + TryCatch.prototype.hasCaught = function () { + return this._caught; + }; + TryCatch.prototype.exception = function () { + return this._exception; + }; + TryCatch.prototype.setError = function (err) { + this._caught = true; + this._exception = err; + }; + TryCatch.prototype.reset = function () { + this._caught = false; + this._exception = undefined; + }; + TryCatch.prototype.extractException = function () { + var e = this._exception; + this.reset(); + return e; + }; + return TryCatch; +}()); +var canSetFunctionName = /*#__PURE__*/ (function () { + var _a; + try { + return Boolean((_a = Object.getOwnPropertyDescriptor(Function.prototype, 'name')) === null || _a === void 0 ? void 0 : _a.configurable); + } + catch (_) { + return false; + } +})(); +var supportReflect = typeof Reflect === 'object'; +var supportFinalizer = (typeof FinalizationRegistry !== 'undefined') && (typeof WeakRef !== 'undefined'); +var supportWeakSymbol = /*#__PURE__*/ (function () { + try { + // eslint-disable-next-line symbol-description + var sym = Symbol(); + // eslint-disable-next-line no-new + new WeakRef(sym); + new WeakMap().set(sym, undefined); + } + catch (_) { + return false; + } + return true; +})(); +var supportBigInt = typeof BigInt !== 'undefined'; +function isReferenceType(v) { + return (typeof v === 'object' && v !== null) || typeof v === 'function'; +} +var _require = /*#__PURE__*/ (function () { + var nativeRequire; + { + nativeRequire = (function () { + return (typeof require !== 'undefined' ? require : undefined); + })(); + } + return nativeRequire; +})(); +var _MessageChannel = typeof MessageChannel === 'function' + ? MessageChannel + : /*#__PURE__*/ (function () { + try { + return _require('worker_threads').MessageChannel; + } + catch (_) { } + return undefined; + })(); +var _setImmediate = typeof setImmediate === 'function' + ? setImmediate + : function (callback) { + if (typeof callback !== 'function') { + throw new TypeError('The "callback" argument must be of type function'); + } + if (_MessageChannel) { + var channel_1 = new _MessageChannel(); + channel_1.port1.onmessage = function () { + channel_1.port1.onmessage = null; + channel_1 = undefined; + callback(); + }; + channel_1.port2.postMessage(null); + } + else { + setTimeout(callback, 0); + } + }; +var _Buffer = typeof Buffer === 'function' + ? Buffer + : /*#__PURE__*/ (function () { + try { + return _require('buffer').Buffer; + } + catch (_) { } + return undefined; + })(); +var version = "1.1.1"; +var NODE_API_SUPPORTED_VERSION_MAX = 9 /* Version.NODE_API_SUPPORTED_VERSION_MAX */; +var NAPI_VERSION_EXPERIMENTAL = 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */; +var NODE_API_DEFAULT_MODULE_API_VERSION = 8 /* Version.NODE_API_DEFAULT_MODULE_API_VERSION */; + +var Handle = /*#__PURE__*/ (function () { + function Handle(id, value) { + this.id = id; + this.value = value; + } + Handle.prototype.data = function (envObject) { + return envObject.getObjectBinding(this.value).data; + }; + Handle.prototype.isNumber = function () { + return typeof this.value === 'number'; + }; + Handle.prototype.isBigInt = function () { + return typeof this.value === 'bigint'; + }; + Handle.prototype.isString = function () { + return typeof this.value === 'string'; + }; + Handle.prototype.isFunction = function () { + return typeof this.value === 'function'; + }; + Handle.prototype.isExternal = function () { + return (isReferenceType(this.value) && Object.getPrototypeOf(this.value) === null); + }; + Handle.prototype.isObject = function () { + return typeof this.value === 'object' && this.value !== null; + }; + Handle.prototype.isArray = function () { + return Array.isArray(this.value); + }; + Handle.prototype.isArrayBuffer = function () { + return (this.value instanceof ArrayBuffer); + }; + Handle.prototype.isTypedArray = function () { + return (ArrayBuffer.isView(this.value)) && !(this.value instanceof DataView); + }; + Handle.prototype.isBuffer = function () { + return typeof _Buffer === 'function' && _Buffer.isBuffer(this.value); + }; + Handle.prototype.isDataView = function () { + return (this.value instanceof DataView); + }; + Handle.prototype.isDate = function () { + return (this.value instanceof Date); + }; + Handle.prototype.isPromise = function () { + return (this.value instanceof Promise); + }; + Handle.prototype.isBoolean = function () { + return typeof this.value === 'boolean'; + }; + Handle.prototype.isUndefined = function () { + return this.value === undefined; + }; + Handle.prototype.isSymbol = function () { + return typeof this.value === 'symbol'; + }; + Handle.prototype.isNull = function () { + return this.value === null; + }; + Handle.prototype.dispose = function () { + this.value = undefined; + }; + return Handle; +}()); +var ConstHandle = /*#__PURE__*/ (function (_super) { + __extends(ConstHandle, _super); + function ConstHandle(id, value) { + return _super.call(this, id, value) || this; + } + ConstHandle.prototype.dispose = function () { }; + return ConstHandle; +}(Handle)); +function External() { + Object.setPrototypeOf(this, null); +} +External.prototype = null; +var HandleStore = /*#__PURE__*/ (function () { + function HandleStore() { + this._values = [ + undefined, + HandleStore.UNDEFINED, + HandleStore.NULL, + HandleStore.FALSE, + HandleStore.TRUE, + HandleStore.GLOBAL + ]; + this._next = HandleStore.MIN_ID; + } + HandleStore.prototype.push = function (value) { + var h; + var next = this._next; + var values = this._values; + if (next < values.length) { + h = values[next]; + h.value = value; + } + else { + h = new Handle(next, value); + values[next] = h; + } + this._next++; + return h; + }; + HandleStore.prototype.erase = function (start, end) { + this._next = start; + var values = this._values; + for (var i = start; i < end; ++i) { + values[i].dispose(); + } + }; + HandleStore.prototype.get = function (id) { + return this._values[id]; + }; + HandleStore.prototype.swap = function (a, b) { + var values = this._values; + var h = values[a]; + values[a] = values[b]; + values[a].id = Number(a); + values[b] = h; + h.id = Number(b); + }; + HandleStore.prototype.dispose = function () { + this._values.length = HandleStore.MIN_ID; + this._next = HandleStore.MIN_ID; + }; + HandleStore.UNDEFINED = new ConstHandle(1 /* GlobalHandle.UNDEFINED */, undefined); + HandleStore.NULL = new ConstHandle(2 /* GlobalHandle.NULL */, null); + HandleStore.FALSE = new ConstHandle(3 /* GlobalHandle.FALSE */, false); + HandleStore.TRUE = new ConstHandle(4 /* GlobalHandle.TRUE */, true); + HandleStore.GLOBAL = new ConstHandle(5 /* GlobalHandle.GLOBAL */, _global); + HandleStore.MIN_ID = 6; + return HandleStore; +}()); + +var HandleScope = /*#__PURE__*/ (function () { + function HandleScope(handleStore, id, parentScope, start, end) { + if (end === void 0) { end = start; } + this.handleStore = handleStore; + this.id = id; + this.parent = parentScope; + this.child = null; + if (parentScope !== null) + parentScope.child = this; + this.start = start; + this.end = end; + this._escapeCalled = false; + } + HandleScope.prototype.add = function (value) { + var h = this.handleStore.push(value); + this.end++; + return h; + }; + HandleScope.prototype.addExternal = function (envObject, data) { + var value = new External(); + var h = envObject.ctx.handleStore.push(value); + var binding = envObject.initObjectBinding(value); + binding.data = data; + this.end++; + return h; + }; + HandleScope.prototype.dispose = function () { + if (this.start === this.end) + return; + this.handleStore.erase(this.start, this.end); + }; + HandleScope.prototype.escape = function (handle) { + if (this._escapeCalled) + return null; + this._escapeCalled = true; + if (handle < this.start || handle >= this.end) { + return null; + } + this.handleStore.swap(handle, this.start); + var h = this.handleStore.get(this.start); + this.start++; + this.parent.end++; + return h; + }; + HandleScope.prototype.escapeCalled = function () { + return this._escapeCalled; + }; + return HandleScope; +}()); + +var ScopeStore = /*#__PURE__*/ (function () { + function ScopeStore() { + this._rootScope = new HandleScope(null, 0, null, 1, HandleStore.MIN_ID); + this.currentScope = this._rootScope; + } + ScopeStore.prototype.get = function (id) { + id = Number(id); + var scope = this.currentScope; + while (scope !== this._rootScope) { + if (scope.id === id) { + return scope; + } + scope = scope.parent; + } + return undefined; + }; + ScopeStore.prototype.openScope = function (envObject) { + var currentScope = this.currentScope; + var scope = currentScope.child; + if (scope !== null) { + scope.start = scope.end = currentScope.end; + scope._escapeCalled = false; + } + else { + scope = new HandleScope(envObject.ctx.handleStore, currentScope.id + 1, currentScope, currentScope.end); + } + this.currentScope = scope; + envObject.openHandleScopes++; + return scope; + }; + ScopeStore.prototype.closeScope = function (envObject) { + if (envObject.openHandleScopes === 0) + return; + var scope = this.currentScope; + this.currentScope = scope.parent; + scope.dispose(); + envObject.openHandleScopes--; + }; + ScopeStore.prototype.dispose = function () { + var scope = this.currentScope; + while (scope !== null) { + scope.handleStore = null; + scope.id = 0; + scope.parent = null; + scope.start = HandleStore.MIN_ID; + scope.end = HandleStore.MIN_ID; + scope._escapeCalled = false; + var child = scope.child; + scope.child = null; + scope = child; + } + this.currentScope = null; + }; + return ScopeStore; +}()); + +var RefTracker = /*#__PURE__*/ (function () { + function RefTracker() { + this._next = null; + this._prev = null; + } + /** @virtual */ + RefTracker.prototype.finalize = function () { }; + RefTracker.prototype.link = function (list) { + this._prev = list; + this._next = list._next; + if (this._next !== null) { + this._next._prev = this; + } + list._next = this; + }; + RefTracker.prototype.unlink = function () { + if (this._prev !== null) { + this._prev._next = this._next; + } + if (this._next !== null) { + this._next._prev = this._prev; + } + this._prev = null; + this._next = null; + }; + RefTracker.finalizeAll = function (list) { + while (list._next !== null) { + list._next.finalize(); + } + }; + return RefTracker; +}()); + +var Finalizer = /*#__PURE__*/ (function () { + function Finalizer(envObject, _finalizeCallback, _finalizeData, _finalizeHint) { + if (_finalizeCallback === void 0) { _finalizeCallback = 0; } + if (_finalizeData === void 0) { _finalizeData = 0; } + if (_finalizeHint === void 0) { _finalizeHint = 0; } + this.envObject = envObject; + this._finalizeCallback = _finalizeCallback; + this._finalizeData = _finalizeData; + this._finalizeHint = _finalizeHint; + } + Finalizer.prototype.callback = function () { return this._finalizeCallback; }; + Finalizer.prototype.data = function () { return this._finalizeData; }; + Finalizer.prototype.hint = function () { return this._finalizeHint; }; + Finalizer.prototype.resetFinalizer = function () { + this._finalizeCallback = 0; + this._finalizeData = 0; + this._finalizeHint = 0; + }; + Finalizer.prototype.dispose = function () { + this.envObject = undefined; + }; + return Finalizer; +}()); + +var TrackedFinalizer = /*#__PURE__*/ (function (_super) { + __extends(TrackedFinalizer, _super); + function TrackedFinalizer(envObject, finalize_callback, finalize_data, finalize_hint) { + var _this = _super.call(this, envObject, finalize_callback, finalize_data, finalize_hint) || this; + _this._next = null; + _this._prev = null; + _this.link(!finalize_callback ? envObject.reflist : envObject.finalizing_reflist); + return _this; + } + TrackedFinalizer.finalizeAll = function (list) { + RefTracker.finalizeAll(list); + }; + TrackedFinalizer.prototype.link = function (list) { + RefTracker.prototype.link.call(this, list); + }; + TrackedFinalizer.prototype.unlink = function () { + RefTracker.prototype.unlink.call(this); + }; + TrackedFinalizer.create = function (envObject, finalize_callback, finalize_data, finalize_hint) { + return new TrackedFinalizer(envObject, finalize_callback, finalize_data, finalize_hint); + }; + TrackedFinalizer.prototype.dispose = function () { + this.unlink(); + this.envObject.dequeueFinalizer(this); + _super.prototype.dispose.call(this); + }; + TrackedFinalizer.prototype.finalize = function () { + this.finalizeCore(true); + }; + TrackedFinalizer.prototype.finalizeCore = function (deleteMe) { + var finalize_callback = this._finalizeCallback; + var finalize_data = this._finalizeData; + var finalize_hint = this._finalizeHint; + this.resetFinalizer(); + this.unlink(); + var error; + var caught = false; + if (finalize_callback) { + var fini = Number(finalize_callback); + try { + this.envObject.callFinalizer(fini, finalize_data, finalize_hint); + } + catch (err) { + caught = true; + error = err; + } + } + if (deleteMe) { + this.dispose(); + } + if (caught) { + throw error; + } + }; + return TrackedFinalizer; +}(Finalizer)); + +var RefBase = /*#__PURE__*/ (function (_super) { + __extends(RefBase, _super); + function RefBase(envObject, initial_refcount, ownership, finalize_callback, finalize_data, finalize_hint) { + var _this = _super.call(this, envObject, finalize_callback, finalize_data, finalize_hint) || this; + _this._refcount = initial_refcount; + _this._ownership = ownership; + return _this; + } + RefBase.prototype.data = function () { + return this._finalizeData; + }; + RefBase.prototype.ref = function () { + return ++this._refcount; + }; + RefBase.prototype.unref = function () { + if (this._refcount === 0) { + return 0; + } + return --this._refcount; + }; + RefBase.prototype.refCount = function () { + return this._refcount; + }; + RefBase.prototype.ownership = function () { + return this._ownership; + }; + RefBase.prototype.finalize = function () { + this.finalizeCore(this._ownership === 0 /* Ownership.kRuntime */); + }; + return RefBase; +}(TrackedFinalizer)); + +function throwNodeApiVersionError(moduleName, moduleApiVersion) { + var errorMessage = "".concat(moduleName, " requires Node-API version ").concat(moduleApiVersion, ", but this version of Node.js only supports version ").concat(NODE_API_SUPPORTED_VERSION_MAX, " add-ons."); + throw new Error(errorMessage); +} +function handleThrow(envObject, value) { + if (envObject.terminatedOrTerminating()) { + return; + } + throw value; +} +var Env = /*#__PURE__*/ (function () { + function Env(ctx, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort) { + this.ctx = ctx; + this.moduleApiVersion = moduleApiVersion; + this.makeDynCall_vppp = makeDynCall_vppp; + this.makeDynCall_vp = makeDynCall_vp; + this.abort = abort; + this.openHandleScopes = 0; + this.instanceData = null; + this.tryCatch = new TryCatch(); + this.refs = 1; + this.reflist = new RefTracker(); + this.finalizing_reflist = new RefTracker(); + this.pendingFinalizers = []; + this.lastError = { + errorCode: 0 /* napi_status.napi_ok */, + engineErrorCode: 0, + engineReserved: 0 + }; + this.inGcFinalizer = false; + this._bindingMap = new WeakMap(); + this.id = 0; + } + /** @virtual */ + Env.prototype.canCallIntoJs = function () { + return true; + }; + Env.prototype.terminatedOrTerminating = function () { + return !this.canCallIntoJs(); + }; + Env.prototype.ref = function () { + this.refs++; + }; + Env.prototype.unref = function () { + this.refs--; + if (this.refs === 0) { + this.dispose(); + } + }; + Env.prototype.ensureHandle = function (value) { + return this.ctx.ensureHandle(value); + }; + Env.prototype.ensureHandleId = function (value) { + return this.ensureHandle(value).id; + }; + Env.prototype.clearLastError = function () { + var lastError = this.lastError; + if (lastError.errorCode !== 0 /* napi_status.napi_ok */) + lastError.errorCode = 0 /* napi_status.napi_ok */; + if (lastError.engineErrorCode !== 0) + lastError.engineErrorCode = 0; + if (lastError.engineReserved !== 0) + lastError.engineReserved = 0; + return 0 /* napi_status.napi_ok */; + }; + Env.prototype.setLastError = function (error_code, engine_error_code, engine_reserved) { + if (engine_error_code === void 0) { engine_error_code = 0; } + if (engine_reserved === void 0) { engine_reserved = 0; } + var lastError = this.lastError; + if (lastError.errorCode !== error_code) + lastError.errorCode = error_code; + if (lastError.engineErrorCode !== engine_error_code) + lastError.engineErrorCode = engine_error_code; + if (lastError.engineReserved !== engine_reserved) + lastError.engineReserved = engine_reserved; + return error_code; + }; + Env.prototype.getReturnStatus = function () { + return !this.tryCatch.hasCaught() ? 0 /* napi_status.napi_ok */ : this.setLastError(10 /* napi_status.napi_pending_exception */); + }; + Env.prototype.callIntoModule = function (fn, handleException) { + if (handleException === void 0) { handleException = handleThrow; } + var openHandleScopesBefore = this.openHandleScopes; + this.clearLastError(); + var r = fn(this); + if (openHandleScopesBefore !== this.openHandleScopes) { + this.abort('open_handle_scopes != open_handle_scopes_before'); + } + if (this.tryCatch.hasCaught()) { + var err = this.tryCatch.extractException(); + handleException(this, err); + } + return r; + }; + /** @virtual */ + Env.prototype.callFinalizer = function (cb, data, hint) { + var f = this.makeDynCall_vppp(cb); + var env = this.id; + var scope = this.ctx.openScope(this); + try { + this.callIntoModule(function () { f(env, data, hint); }); + } + finally { + this.ctx.closeScope(this, scope); + } + }; + Env.prototype.invokeFinalizerFromGC = function (finalizer) { + if (this.moduleApiVersion !== NAPI_VERSION_EXPERIMENTAL) { + this.enqueueFinalizer(finalizer); + } + else { + var saved = this.inGcFinalizer; + this.inGcFinalizer = true; + try { + finalizer.finalize(); + } + finally { + this.inGcFinalizer = saved; + } + } + }; + Env.prototype.checkGCAccess = function () { + if (this.moduleApiVersion === NAPI_VERSION_EXPERIMENTAL && this.inGcFinalizer) { + this.abort('Finalizer is calling a function that may affect GC state.\n' + + 'The finalizers are run directly from GC and must not affect GC ' + + 'state.\n' + + 'Use `node_api_post_finalizer` from inside of the finalizer to work ' + + 'around this issue.\n' + + 'It schedules the call as a new task in the event loop.'); + } + }; + /** @virtual */ + Env.prototype.enqueueFinalizer = function (finalizer) { + if (this.pendingFinalizers.indexOf(finalizer) === -1) { + this.pendingFinalizers.push(finalizer); + } + }; + /** @virtual */ + Env.prototype.dequeueFinalizer = function (finalizer) { + var index = this.pendingFinalizers.indexOf(finalizer); + if (index !== -1) { + this.pendingFinalizers.splice(index, 1); + } + }; + /** @virtual */ + Env.prototype.deleteMe = function () { + RefBase.finalizeAll(this.finalizing_reflist); + RefBase.finalizeAll(this.reflist); + this.tryCatch.extractException(); + this.ctx.envStore.remove(this.id); + }; + Env.prototype.dispose = function () { + if (this.id === 0) + return; + this.deleteMe(); + this.id = 0; + }; + Env.prototype.initObjectBinding = function (value) { + var binding = { + wrapped: 0, + tag: null, + data: 0 + }; + this._bindingMap.set(value, binding); + return binding; + }; + Env.prototype.getObjectBinding = function (value) { + if (this._bindingMap.has(value)) { + return this._bindingMap.get(value); + } + return this.initObjectBinding(value); + }; + Env.prototype.setInstanceData = function (data, finalize_cb, finalize_hint) { + if (this.instanceData) { + this.instanceData.dispose(); + } + this.instanceData = new RefBase(this, 0, 0 /* Ownership.kRuntime */, finalize_cb, data, finalize_hint); + }; + Env.prototype.getInstanceData = function () { + return this.instanceData ? this.instanceData.data() : 0; + }; + return Env; +}()); +var NodeEnv = /*#__PURE__*/ (function (_super) { + __extends(NodeEnv, _super); + function NodeEnv(ctx, filename, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort, nodeBinding) { + var _this = _super.call(this, ctx, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort) || this; + _this.filename = filename; + _this.nodeBinding = nodeBinding; + _this.destructing = false; + _this.finalizationScheduled = false; + return _this; + } + NodeEnv.prototype.deleteMe = function () { + this.destructing = true; + this.drainFinalizerQueue(); + _super.prototype.deleteMe.call(this); + }; + NodeEnv.prototype.canCallIntoJs = function () { + return _super.prototype.canCallIntoJs.call(this) && this.ctx.canCallIntoJs(); + }; + NodeEnv.prototype.triggerFatalException = function (err) { + if (this.nodeBinding) { + this.nodeBinding.napi.fatalException(err); + } + else { + { + throw err; + } + } + }; + NodeEnv.prototype.callbackIntoModule = function (enforceUncaughtExceptionPolicy, fn) { + return this.callIntoModule(fn, function (envObject, err) { + if (envObject.terminatedOrTerminating()) { + return; + } + var hasForceFlag = false; + if (envObject.moduleApiVersion < NAPI_VERSION_EXPERIMENTAL && !hasForceFlag && !enforceUncaughtExceptionPolicy) { + var warn = function (warning, type, code) { + if (warning instanceof Error) { + console.warn(warning.toString()); + } + else { + var prefix = code ? "[".concat(code, "] ") : ''; + // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing + console.warn("".concat(prefix).concat(type || 'Warning', ": ").concat(warning)); + } + }; + warn('Uncaught N-API callback exception detected, please run node with option --force-node-api-uncaught-exceptions-policy=true to handle those exceptions properly.', 'DeprecationWarning', 'DEP0168'); + return; + } + envObject.triggerFatalException(err); + }); + }; + NodeEnv.prototype.callFinalizer = function (cb, data, hint) { + this.callFinalizerInternal(1, cb, data, hint); + }; + NodeEnv.prototype.callFinalizerInternal = function (forceUncaught, cb, data, hint) { + var f = this.makeDynCall_vppp(cb); + var env = this.id; + var scope = this.ctx.openScope(this); + try { + this.callbackIntoModule(Boolean(forceUncaught), function () { f(env, data, hint); }); + } + finally { + this.ctx.closeScope(this, scope); + } + }; + NodeEnv.prototype.enqueueFinalizer = function (finalizer) { + var _this = this; + _super.prototype.enqueueFinalizer.call(this, finalizer); + if (!this.finalizationScheduled && !this.destructing) { + this.finalizationScheduled = true; + this.ref(); + _setImmediate(function () { + _this.finalizationScheduled = false; + _this.unref(); + _this.drainFinalizerQueue(); + }); + } + }; + NodeEnv.prototype.drainFinalizerQueue = function () { + while (this.pendingFinalizers.length > 0) { + var refTracker = this.pendingFinalizers.shift(); + refTracker.finalize(); + } + }; + return NodeEnv; +}(Env)); +function newEnv(ctx, filename, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort, nodeBinding) { + moduleApiVersion = typeof moduleApiVersion !== 'number' ? NODE_API_DEFAULT_MODULE_API_VERSION : moduleApiVersion; + // Validate module_api_version. + if (moduleApiVersion < NODE_API_DEFAULT_MODULE_API_VERSION) { + moduleApiVersion = NODE_API_DEFAULT_MODULE_API_VERSION; + } + else if (moduleApiVersion > NODE_API_SUPPORTED_VERSION_MAX && moduleApiVersion !== NAPI_VERSION_EXPERIMENTAL) { + throwNodeApiVersionError(filename, moduleApiVersion); + } + var env = new NodeEnv(ctx, filename, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort, nodeBinding); + ctx.envStore.add(env); + ctx.addCleanupHook(env, function () { env.unref(); }, 0); + return env; +} + +var EmnapiError = /*#__PURE__*/ (function (_super) { + __extends(EmnapiError, _super); + function EmnapiError(message) { + var _newTarget = this.constructor; + var _this = _super.call(this, message) || this; + var ErrorConstructor = _newTarget; + var proto = ErrorConstructor.prototype; + if (!(_this instanceof EmnapiError)) { + var setPrototypeOf = Object.setPrototypeOf; + if (typeof setPrototypeOf === 'function') { + setPrototypeOf.call(Object, _this, proto); + } + else { + // eslint-disable-next-line no-proto + _this.__proto__ = proto; + } + if (typeof Error.captureStackTrace === 'function') { + Error.captureStackTrace(_this, ErrorConstructor); + } + } + return _this; + } + return EmnapiError; +}(Error)); +Object.defineProperty(EmnapiError.prototype, 'name', { + configurable: true, + writable: true, + value: 'EmnapiError' +}); +var NotSupportWeakRefError = /*#__PURE__*/ (function (_super) { + __extends(NotSupportWeakRefError, _super); + function NotSupportWeakRefError(api, message) { + return _super.call(this, "".concat(api, ": The current runtime does not support \"FinalizationRegistry\" and \"WeakRef\".").concat(message ? " ".concat(message) : '')) || this; + } + return NotSupportWeakRefError; +}(EmnapiError)); +Object.defineProperty(NotSupportWeakRefError.prototype, 'name', { + configurable: true, + writable: true, + value: 'NotSupportWeakRefError' +}); +var NotSupportBufferError = /*#__PURE__*/ (function (_super) { + __extends(NotSupportBufferError, _super); + function NotSupportBufferError(api, message) { + return _super.call(this, "".concat(api, ": The current runtime does not support \"Buffer\". Consider using buffer polyfill to make sure `globalThis.Buffer` is defined.").concat(message ? " ".concat(message) : '')) || this; + } + return NotSupportBufferError; +}(EmnapiError)); +Object.defineProperty(NotSupportBufferError.prototype, 'name', { + configurable: true, + writable: true, + value: 'NotSupportBufferError' +}); + +var StrongRef = /*#__PURE__*/ (function () { + function StrongRef(value) { + this._value = value; + } + StrongRef.prototype.deref = function () { + return this._value; + }; + StrongRef.prototype.dispose = function () { + this._value = undefined; + }; + return StrongRef; +}()); +var Persistent = /*#__PURE__*/ (function () { + function Persistent(value) { + this._ref = new StrongRef(value); + } + Persistent.prototype.setWeak = function (param, callback) { + if (!supportFinalizer || this._ref === undefined || this._ref instanceof WeakRef) + return; + var value = this._ref.deref(); + try { + Persistent._registry.register(value, this, this); + var weakRef = new WeakRef(value); + this._ref.dispose(); + this._ref = weakRef; + this._param = param; + this._callback = callback; + } + catch (err) { + if (typeof value === 'symbol') ; + else { + throw err; + } + } + }; + Persistent.prototype.clearWeak = function () { + if (!supportFinalizer || this._ref === undefined) + return; + if (this._ref instanceof WeakRef) { + try { + Persistent._registry.unregister(this); + } + catch (_) { } + this._param = undefined; + this._callback = undefined; + var value = this._ref.deref(); + if (value === undefined) { + this._ref = value; + } + else { + this._ref = new StrongRef(value); + } + } + }; + Persistent.prototype.reset = function () { + if (supportFinalizer) { + try { + Persistent._registry.unregister(this); + } + catch (_) { } + } + this._param = undefined; + this._callback = undefined; + if (this._ref instanceof StrongRef) { + this._ref.dispose(); + } + this._ref = undefined; + }; + Persistent.prototype.isEmpty = function () { + return this._ref === undefined; + }; + Persistent.prototype.deref = function () { + if (this._ref === undefined) + return undefined; + return this._ref.deref(); + }; + Persistent._registry = supportFinalizer + ? new FinalizationRegistry(function (value) { + value._ref = undefined; + var callback = value._callback; + var param = value._param; + value._callback = undefined; + value._param = undefined; + if (typeof callback === 'function') { + callback(param); + } + }) + : undefined; + return Persistent; +}()); + +function weakCallback(ref) { + ref.persistent.reset(); + ref.envObject.invokeFinalizerFromGC(ref); +} +function canBeHeldWeakly(value) { + return value.isObject() || value.isFunction() || value.isSymbol(); +} +var Reference = /*#__PURE__*/ (function (_super) { + __extends(Reference, _super); + function Reference(envObject, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) { + if (finalize_callback === void 0) { finalize_callback = 0; } + if (finalize_data === void 0) { finalize_data = 0; } + if (finalize_hint === void 0) { finalize_hint = 0; } + var _this = _super.call(this, envObject, initialRefcount >>> 0, ownership, finalize_callback, finalize_data, finalize_hint) || this; + _this.id = 0; + return _this; + } + Reference.create = function (envObject, handle_id, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) { + if (finalize_callback === void 0) { finalize_callback = 0; } + if (finalize_data === void 0) { finalize_data = 0; } + if (finalize_hint === void 0) { finalize_hint = 0; } + var handle = envObject.ctx.handleStore.get(handle_id); + var ref = new Reference(envObject, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint); + envObject.ctx.refStore.add(ref); + ref.canBeWeak = canBeHeldWeakly(handle); + ref.persistent = new Persistent(handle.value); + if (initialRefcount === 0) { + ref._setWeak(); + } + return ref; + }; + Reference.prototype.ref = function () { + if (this.persistent.isEmpty()) { + return 0; + } + var count = _super.prototype.ref.call(this); + if (count === 1 && this.canBeWeak) { + this.persistent.clearWeak(); + } + return count; + }; + Reference.prototype.unref = function () { + if (this.persistent.isEmpty()) { + return 0; + } + var oldRefcount = this.refCount(); + var refcount = _super.prototype.unref.call(this); + if (oldRefcount === 1 && refcount === 0) { + this._setWeak(); + } + return refcount; + }; + Reference.prototype.get = function () { + if (this.persistent.isEmpty()) { + return 0; + } + var obj = this.persistent.deref(); + var handle = this.envObject.ensureHandle(obj); + return handle.id; + }; + Reference.prototype._setWeak = function () { + if (this.canBeWeak) { + this.persistent.setWeak(this, weakCallback); + } + else { + this.persistent.reset(); + } + }; + Reference.prototype.finalize = function () { + this.persistent.reset(); + _super.prototype.finalize.call(this); + }; + Reference.prototype.dispose = function () { + if (this.id === 0) + return; + this.persistent.reset(); + this.envObject.ctx.refStore.remove(this.id); + _super.prototype.dispose.call(this); + this.id = 0; + }; + return Reference; +}(RefBase)); + +var Deferred = /*#__PURE__*/ (function () { + function Deferred(ctx, value) { + this.id = 0; + this.ctx = ctx; + this.value = value; + } + Deferred.create = function (ctx, value) { + var deferred = new Deferred(ctx, value); + ctx.deferredStore.add(deferred); + return deferred; + }; + Deferred.prototype.resolve = function (value) { + this.value.resolve(value); + this.dispose(); + }; + Deferred.prototype.reject = function (reason) { + this.value.reject(reason); + this.dispose(); + }; + Deferred.prototype.dispose = function () { + this.ctx.deferredStore.remove(this.id); + this.id = 0; + this.value = null; + this.ctx = null; + }; + return Deferred; +}()); + +var Store = /*#__PURE__*/ (function () { + function Store() { + this._values = [undefined]; + this._values.length = 4; + this._size = 1; + this._freeList = []; + } + Store.prototype.add = function (value) { + var id; + if (this._freeList.length) { + id = this._freeList.shift(); + } + else { + id = this._size; + this._size++; + var capacity = this._values.length; + if (id >= capacity) { + this._values.length = capacity + (capacity >> 1) + 16; + } + } + value.id = id; + this._values[id] = value; + }; + Store.prototype.get = function (id) { + return this._values[id]; + }; + Store.prototype.has = function (id) { + return this._values[id] !== undefined; + }; + Store.prototype.remove = function (id) { + var value = this._values[id]; + if (value) { + value.id = 0; + this._values[id] = undefined; + this._freeList.push(Number(id)); + } + }; + Store.prototype.dispose = function () { + for (var i = 1; i < this._size; ++i) { + var value = this._values[i]; + value === null || value === void 0 ? void 0 : value.dispose(); + } + this._values = [undefined]; + this._size = 1; + this._freeList = []; + }; + return Store; +}()); + +var CleanupHookCallback = /*#__PURE__*/ (function () { + function CleanupHookCallback(envObject, fn, arg, order) { + this.envObject = envObject; + this.fn = fn; + this.arg = arg; + this.order = order; + } + return CleanupHookCallback; +}()); +var CleanupQueue = /*#__PURE__*/ (function () { + function CleanupQueue() { + this._cleanupHooks = []; + this._cleanupHookCounter = 0; + } + CleanupQueue.prototype.empty = function () { + return this._cleanupHooks.length === 0; + }; + CleanupQueue.prototype.add = function (envObject, fn, arg) { + if (this._cleanupHooks.filter(function (hook) { return (hook.envObject === envObject && hook.fn === fn && hook.arg === arg); }).length > 0) { + throw new Error('Can not add same fn and arg twice'); + } + this._cleanupHooks.push(new CleanupHookCallback(envObject, fn, arg, this._cleanupHookCounter++)); + }; + CleanupQueue.prototype.remove = function (envObject, fn, arg) { + for (var i = 0; i < this._cleanupHooks.length; ++i) { + var hook = this._cleanupHooks[i]; + if (hook.envObject === envObject && hook.fn === fn && hook.arg === arg) { + this._cleanupHooks.splice(i, 1); + return; + } + } + }; + CleanupQueue.prototype.drain = function () { + var hooks = this._cleanupHooks.slice(); + hooks.sort(function (a, b) { return (b.order - a.order); }); + for (var i = 0; i < hooks.length; ++i) { + var cb = hooks[i]; + if (typeof cb.fn === 'number') { + cb.envObject.makeDynCall_vp(cb.fn)(cb.arg); + } + else { + cb.fn(cb.arg); + } + this._cleanupHooks.splice(this._cleanupHooks.indexOf(cb), 1); + } + }; + CleanupQueue.prototype.dispose = function () { + this._cleanupHooks.length = 0; + this._cleanupHookCounter = 0; + }; + return CleanupQueue; +}()); +var Context = /*#__PURE__*/ (function () { + function Context() { + this._isStopping = false; + this._canCallIntoJs = true; + this.envStore = new Store(); + this.scopeStore = new ScopeStore(); + this.refStore = new Store(); + this.deferredStore = new Store(); + this.handleStore = new HandleStore(); + this.cbinfoStack = new CallbackInfoStack(); + this.feature = { + supportReflect: supportReflect, + supportFinalizer: supportFinalizer, + supportWeakSymbol: supportWeakSymbol, + supportBigInt: supportBigInt, + supportNewFunction: supportNewFunction, + canSetFunctionName: canSetFunctionName, + setImmediate: _setImmediate, + Buffer: _Buffer, + MessageChannel: _MessageChannel + }; + this.cleanupQueue = new CleanupQueue(); + } + // eslint-disable-next-line @typescript-eslint/explicit-function-return-type + Context.prototype.getRuntimeVersions = function () { + return { + version: version, + NODE_API_SUPPORTED_VERSION_MAX: NODE_API_SUPPORTED_VERSION_MAX, + NAPI_VERSION_EXPERIMENTAL: NAPI_VERSION_EXPERIMENTAL, + NODE_API_DEFAULT_MODULE_API_VERSION: NODE_API_DEFAULT_MODULE_API_VERSION + }; + }; + Context.prototype.createNotSupportWeakRefError = function (api, message) { + return new NotSupportWeakRefError(api, message); + }; + Context.prototype.createNotSupportBufferError = function (api, message) { + return new NotSupportBufferError(api, message); + }; + Context.prototype.createReference = function (envObject, handle_id, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) { + if (finalize_callback === void 0) { finalize_callback = 0; } + if (finalize_data === void 0) { finalize_data = 0; } + if (finalize_hint === void 0) { finalize_hint = 0; } + return Reference.create(envObject, handle_id, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint); + }; + Context.prototype.createDeferred = function (value) { + return Deferred.create(this, value); + }; + Context.prototype.createEnv = function (filename, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort, nodeBinding) { + return newEnv(this, filename, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort, nodeBinding); + }; + Context.prototype.createTrackedFinalizer = function (envObject, finalize_callback, finalize_data, finalize_hint) { + return TrackedFinalizer.create(envObject, finalize_callback, finalize_data, finalize_hint); + }; + Context.prototype.getCurrentScope = function () { + return this.scopeStore.currentScope; + }; + Context.prototype.addToCurrentScope = function (value) { + return this.scopeStore.currentScope.add(value); + }; + Context.prototype.openScope = function (envObject) { + return this.scopeStore.openScope(envObject); + }; + Context.prototype.closeScope = function (envObject, _scope) { + this.scopeStore.closeScope(envObject); + }; + Context.prototype.ensureHandle = function (value) { + switch (value) { + case undefined: return HandleStore.UNDEFINED; + case null: return HandleStore.NULL; + case true: return HandleStore.TRUE; + case false: return HandleStore.FALSE; + case _global: return HandleStore.GLOBAL; + } + return this.addToCurrentScope(value); + }; + Context.prototype.addCleanupHook = function (envObject, fn, arg) { + this.cleanupQueue.add(envObject, fn, arg); + }; + Context.prototype.removeCleanupHook = function (envObject, fn, arg) { + this.cleanupQueue.remove(envObject, fn, arg); + }; + Context.prototype.runCleanup = function () { + while (!this.cleanupQueue.empty()) { + this.cleanupQueue.drain(); + } + }; + Context.prototype.increaseWaitingRequestCounter = function () { + var _a; + (_a = this.refCounter) === null || _a === void 0 ? void 0 : _a.increase(); + }; + Context.prototype.decreaseWaitingRequestCounter = function () { + var _a; + (_a = this.refCounter) === null || _a === void 0 ? void 0 : _a.decrease(); + }; + Context.prototype.setCanCallIntoJs = function (value) { + this._canCallIntoJs = value; + }; + Context.prototype.setStopping = function (value) { + this._isStopping = value; + }; + Context.prototype.canCallIntoJs = function () { + return this._canCallIntoJs && !this._isStopping; + }; + Context.prototype.destroy = function () { + this.setStopping(true); + this.setCanCallIntoJs(false); + this.runCleanup(); + }; + return Context; +}()); +var defaultContext; +function createContext() { + return new Context(); +} +function getDefaultContext() { + if (!defaultContext) { + defaultContext = createContext(); + } + return defaultContext; +} + +const _WebAssembly = typeof WebAssembly !== 'undefined' + ? WebAssembly + : typeof WXWebAssembly !== 'undefined' + ? WXWebAssembly + : undefined; +if (!_WebAssembly) { + throw new Error('WebAssembly is not supported in this environment'); +} + +/* eslint-disable spaced-comment */ + +function validateObject(value, name) { + if (value === null || typeof value !== 'object') { + throw new TypeError(`${name} must be an object. Received ${value === null ? 'null' : typeof value}`); + } +} +function validateArray(value, name) { + if (!Array.isArray(value)) { + throw new TypeError(`${name} must be an array. Received ${value === null ? 'null' : typeof value}`); + } +} +function validateBoolean(value, name) { + if (typeof value !== 'boolean') { + throw new TypeError(`${name} must be a boolean. Received ${value === null ? 'null' : typeof value}`); + } +} +function validateString(value, name) { + if (typeof value !== 'string') { + throw new TypeError(`${name} must be a string. Received ${value === null ? 'null' : typeof value}`); + } +} +function validateFunction(value, name) { + if (typeof value !== 'function') { + throw new TypeError(`${name} must be a function. Received ${value === null ? 'null' : typeof value}`); + } +} +function validateUndefined(value, name) { + if (value !== undefined) { + throw new TypeError(`${name} must be undefined. Received ${value === null ? 'null' : typeof value}`); + } +} +function isPromiseLike(obj) { + return !!(obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function'); +} +function unsharedSlice(view, start, end) { + return ((typeof SharedArrayBuffer === 'function' && view.buffer instanceof SharedArrayBuffer) || (Object.prototype.toString.call(view.buffer.constructor) === '[object SharedArrayBuffer]')) + ? view.slice(start, end) + : view.subarray(start, end); +} + +const CHAR_DOT = 46; /* . */ +const CHAR_FORWARD_SLASH = 47; /* / */ +function isPosixPathSeparator(code) { + return code === CHAR_FORWARD_SLASH; +} +function normalizeString(path, allowAboveRoot, separator, isPathSeparator) { + let res = ''; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let code = 0; + for (let i = 0; i <= path.length; ++i) { + if (i < path.length) { + code = path.charCodeAt(i); + } + else if (isPathSeparator(code)) { + break; + } + else { + code = CHAR_FORWARD_SLASH; + } + if (isPathSeparator(code)) { + if (lastSlash === i - 1 || dots === 1) ; + else if (dots === 2) { + if (res.length < 2 || lastSegmentLength !== 2 || + res.charCodeAt(res.length - 1) !== CHAR_DOT || + res.charCodeAt(res.length - 2) !== CHAR_DOT) { + if (res.length > 2) { + const lastSlashIndex = res.indexOf(separator); + if (lastSlashIndex === -1) { + res = ''; + lastSegmentLength = 0; + } + else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = + res.length - 1 - res.indexOf(separator); + } + lastSlash = i; + dots = 0; + continue; + } + else if (res.length !== 0) { + res = ''; + lastSegmentLength = 0; + lastSlash = i; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + res += res.length > 0 ? `${separator}..` : '..'; + lastSegmentLength = 2; + } + } + else { + if (res.length > 0) { + res += `${separator}${path.slice(lastSlash + 1, i)}`; + } + else { + res = path.slice(lastSlash + 1, i); + } + lastSegmentLength = i - lastSlash - 1; + } + lastSlash = i; + dots = 0; + } + else if (code === CHAR_DOT && dots !== -1) { + ++dots; + } + else { + dots = -1; + } + } + return res; +} +function resolve(...args) { + let resolvedPath = ''; + let resolvedAbsolute = false; + for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) { + const path = i >= 0 ? args[i] : '/'; + validateString(path, 'path'); + // Skip empty entries + if (path.length === 0) { + continue; + } + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + // Normalize the path + resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator); + if (resolvedAbsolute) { + return `/${resolvedPath}`; + } + return resolvedPath.length > 0 ? resolvedPath : '.'; +} + +const FD_DATASYNC = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(0)); +const FD_READ = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(1)); +const FD_SEEK = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(2)); +const FD_FDSTAT_SET_FLAGS = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(3)); +const FD_SYNC = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(4)); +const FD_TELL = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(5)); +const FD_WRITE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(6)); +const FD_ADVISE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(7)); +const FD_ALLOCATE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(8)); +const PATH_CREATE_DIRECTORY = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(9)); +const PATH_CREATE_FILE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(10)); +const PATH_LINK_SOURCE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(11)); +const PATH_LINK_TARGET = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(12)); +const PATH_OPEN = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(13)); +const FD_READDIR = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(14)); +const PATH_READLINK = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(15)); +const PATH_RENAME_SOURCE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(16)); +const PATH_RENAME_TARGET = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(17)); +const PATH_FILESTAT_GET = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(18)); +const PATH_FILESTAT_SET_SIZE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(19)); +const PATH_FILESTAT_SET_TIMES = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(20)); +const FD_FILESTAT_GET = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(21)); +const FD_FILESTAT_SET_SIZE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(22)); +const FD_FILESTAT_SET_TIMES = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(23)); +const PATH_SYMLINK = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(24)); +const PATH_REMOVE_DIRECTORY = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(25)); +const PATH_UNLINK_FILE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(26)); +const POLL_FD_READWRITE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(27)); +const SOCK_SHUTDOWN = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(28)); +const SOCK_ACCEPT = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(29)); +const WasiRights = { + FD_DATASYNC, + FD_READ, + FD_SEEK, + FD_FDSTAT_SET_FLAGS, + FD_SYNC, + FD_TELL, + FD_WRITE, + FD_ADVISE, + FD_ALLOCATE, + PATH_CREATE_DIRECTORY, + PATH_CREATE_FILE, + PATH_LINK_SOURCE, + PATH_LINK_TARGET, + PATH_OPEN, + FD_READDIR, + PATH_READLINK, + PATH_RENAME_SOURCE, + PATH_RENAME_TARGET, + PATH_FILESTAT_GET, + PATH_FILESTAT_SET_SIZE, + PATH_FILESTAT_SET_TIMES, + FD_FILESTAT_GET, + FD_FILESTAT_SET_SIZE, + FD_FILESTAT_SET_TIMES, + PATH_SYMLINK, + PATH_REMOVE_DIRECTORY, + PATH_UNLINK_FILE, + POLL_FD_READWRITE, + SOCK_SHUTDOWN, + SOCK_ACCEPT +}; + +function strerror(errno) { + switch (errno) { + case 0 /* WasiErrno.ESUCCESS */: return 'Success'; + case 1 /* WasiErrno.E2BIG */: return 'Argument list too long'; + case 2 /* WasiErrno.EACCES */: return 'Permission denied'; + case 3 /* WasiErrno.EADDRINUSE */: return 'Address in use'; + case 4 /* WasiErrno.EADDRNOTAVAIL */: return 'Address not available'; + case 5 /* WasiErrno.EAFNOSUPPORT */: return 'Address family not supported by protocol'; + case 6 /* WasiErrno.EAGAIN */: return 'Resource temporarily unavailable'; + case 7 /* WasiErrno.EALREADY */: return 'Operation already in progress'; + case 8 /* WasiErrno.EBADF */: return 'Bad file descriptor'; + case 9 /* WasiErrno.EBADMSG */: return 'Bad message'; + case 10 /* WasiErrno.EBUSY */: return 'Resource busy'; + case 11 /* WasiErrno.ECANCELED */: return 'Operation canceled'; + case 12 /* WasiErrno.ECHILD */: return 'No child null'; + case 13 /* WasiErrno.ECONNABORTED */: return 'Connection aborted'; + case 14 /* WasiErrno.ECONNREFUSED */: return 'Connection refused'; + case 15 /* WasiErrno.ECONNRESET */: return 'Connection reset by peer'; + case 16 /* WasiErrno.EDEADLK */: return 'Resource deadlock would occur'; + case 17 /* WasiErrno.EDESTADDRREQ */: return 'Destination address required'; + case 18 /* WasiErrno.EDOM */: return 'Domain error'; + case 19 /* WasiErrno.EDQUOT */: return 'Quota exceeded'; + case 20 /* WasiErrno.EEXIST */: return 'File exists'; + case 21 /* WasiErrno.EFAULT */: return 'Bad address'; + case 22 /* WasiErrno.EFBIG */: return 'File too large'; + case 23 /* WasiErrno.EHOSTUNREACH */: return 'Host is unreachable'; + case 24 /* WasiErrno.EIDRM */: return 'Identifier removed'; + case 25 /* WasiErrno.EILSEQ */: return 'Illegal byte sequence'; + case 26 /* WasiErrno.EINPROGRESS */: return 'Operation in progress'; + case 27 /* WasiErrno.EINTR */: return 'Interrupted system call'; + case 28 /* WasiErrno.EINVAL */: return 'Invalid argument'; + case 29 /* WasiErrno.EIO */: return 'I/O error'; + case 30 /* WasiErrno.EISCONN */: return 'Socket is connected'; + case 31 /* WasiErrno.EISDIR */: return 'Is a directory'; + case 32 /* WasiErrno.ELOOP */: return 'Symbolic link loop'; + case 33 /* WasiErrno.EMFILE */: return 'No file descriptors available'; + case 34 /* WasiErrno.EMLINK */: return 'Too many links'; + case 35 /* WasiErrno.EMSGSIZE */: return 'Message too large'; + case 36 /* WasiErrno.EMULTIHOP */: return 'Multihop attempted'; + case 37 /* WasiErrno.ENAMETOOLONG */: return 'Filename too long'; + case 38 /* WasiErrno.ENETDOWN */: return 'Network is down'; + case 39 /* WasiErrno.ENETRESET */: return 'Connection reset by network'; + case 40 /* WasiErrno.ENETUNREACH */: return 'Network unreachable'; + case 41 /* WasiErrno.ENFILE */: return 'Too many files open in system'; + case 42 /* WasiErrno.ENOBUFS */: return 'No buffer space available'; + case 43 /* WasiErrno.ENODEV */: return 'No such device'; + case 44 /* WasiErrno.ENOENT */: return 'No such file or directory'; + case 45 /* WasiErrno.ENOEXEC */: return 'Exec format error'; + case 46 /* WasiErrno.ENOLCK */: return 'No locks available'; + case 47 /* WasiErrno.ENOLINK */: return 'Link has been severed'; + case 48 /* WasiErrno.ENOMEM */: return 'Out of memory'; + case 49 /* WasiErrno.ENOMSG */: return 'No message of the desired type'; + case 50 /* WasiErrno.ENOPROTOOPT */: return 'Protocol not available'; + case 51 /* WasiErrno.ENOSPC */: return 'No space left on device'; + case 52 /* WasiErrno.ENOSYS */: return 'Function not implemented'; + case 53 /* WasiErrno.ENOTCONN */: return 'Socket not connected'; + case 54 /* WasiErrno.ENOTDIR */: return 'Not a directory'; + case 55 /* WasiErrno.ENOTEMPTY */: return 'Directory not empty'; + case 56 /* WasiErrno.ENOTRECOVERABLE */: return 'State not recoverable'; + case 57 /* WasiErrno.ENOTSOCK */: return 'Not a socket'; + case 58 /* WasiErrno.ENOTSUP */: return 'Not supported'; + case 59 /* WasiErrno.ENOTTY */: return 'Not a tty'; + case 60 /* WasiErrno.ENXIO */: return 'No such device or address'; + case 61 /* WasiErrno.EOVERFLOW */: return 'Value too large for data type'; + case 62 /* WasiErrno.EOWNERDEAD */: return 'Previous owner died'; + case 63 /* WasiErrno.EPERM */: return 'Operation not permitted'; + case 64 /* WasiErrno.EPIPE */: return 'Broken pipe'; + case 65 /* WasiErrno.EPROTO */: return 'Protocol error'; + case 66 /* WasiErrno.EPROTONOSUPPORT */: return 'Protocol not supported'; + case 67 /* WasiErrno.EPROTOTYPE */: return 'Protocol wrong type for socket'; + case 68 /* WasiErrno.ERANGE */: return 'Result not representable'; + case 69 /* WasiErrno.EROFS */: return 'Read-only file system'; + case 70 /* WasiErrno.ESPIPE */: return 'Invalid seek'; + case 71 /* WasiErrno.ESRCH */: return 'No such null'; + case 72 /* WasiErrno.ESTALE */: return 'Stale file handle'; + case 73 /* WasiErrno.ETIMEDOUT */: return 'Operation timed out'; + case 74 /* WasiErrno.ETXTBSY */: return 'Text file busy'; + case 75 /* WasiErrno.EXDEV */: return 'Cross-device link'; + case 76 /* WasiErrno.ENOTCAPABLE */: return 'Capabilities insufficient'; + default: return 'Unknown error'; + } +} +class WasiError extends Error { + constructor(message, errno) { + super(message); + this.errno = errno; + } + getErrorMessage() { + return strerror(this.errno); + } +} +Object.defineProperty(WasiError.prototype, 'name', { + configurable: true, + writable: true, + value: 'WasiError' +}); + +const RIGHTS_ALL = WasiRights.FD_DATASYNC | + WasiRights.FD_READ | + WasiRights.FD_SEEK | + WasiRights.FD_FDSTAT_SET_FLAGS | + WasiRights.FD_SYNC | + WasiRights.FD_TELL | + WasiRights.FD_WRITE | + WasiRights.FD_ADVISE | + WasiRights.FD_ALLOCATE | + WasiRights.PATH_CREATE_DIRECTORY | + WasiRights.PATH_CREATE_FILE | + WasiRights.PATH_LINK_SOURCE | + WasiRights.PATH_LINK_TARGET | + WasiRights.PATH_OPEN | + WasiRights.FD_READDIR | + WasiRights.PATH_READLINK | + WasiRights.PATH_RENAME_SOURCE | + WasiRights.PATH_RENAME_TARGET | + WasiRights.PATH_FILESTAT_GET | + WasiRights.PATH_FILESTAT_SET_SIZE | + WasiRights.PATH_FILESTAT_SET_TIMES | + WasiRights.FD_FILESTAT_GET | + WasiRights.FD_FILESTAT_SET_TIMES | + WasiRights.FD_FILESTAT_SET_SIZE | + WasiRights.PATH_SYMLINK | + WasiRights.PATH_UNLINK_FILE | + WasiRights.PATH_REMOVE_DIRECTORY | + WasiRights.POLL_FD_READWRITE | + WasiRights.SOCK_SHUTDOWN | + WasiRights.SOCK_ACCEPT; +const BLOCK_DEVICE_BASE = RIGHTS_ALL; +const BLOCK_DEVICE_INHERITING = RIGHTS_ALL; +const CHARACTER_DEVICE_BASE = RIGHTS_ALL; +const CHARACTER_DEVICE_INHERITING = RIGHTS_ALL; +const REGULAR_FILE_BASE = WasiRights.FD_DATASYNC | + WasiRights.FD_READ | + WasiRights.FD_SEEK | + WasiRights.FD_FDSTAT_SET_FLAGS | + WasiRights.FD_SYNC | + WasiRights.FD_TELL | + WasiRights.FD_WRITE | + WasiRights.FD_ADVISE | + WasiRights.FD_ALLOCATE | + WasiRights.FD_FILESTAT_GET | + WasiRights.FD_FILESTAT_SET_SIZE | + WasiRights.FD_FILESTAT_SET_TIMES | + WasiRights.POLL_FD_READWRITE; +const REGULAR_FILE_INHERITING = /*#__PURE__*/ BigInt(0); +const DIRECTORY_BASE = WasiRights.FD_FDSTAT_SET_FLAGS | + WasiRights.FD_SYNC | + WasiRights.FD_ADVISE | + WasiRights.PATH_CREATE_DIRECTORY | + WasiRights.PATH_CREATE_FILE | + WasiRights.PATH_LINK_SOURCE | + WasiRights.PATH_LINK_TARGET | + WasiRights.PATH_OPEN | + WasiRights.FD_READDIR | + WasiRights.PATH_READLINK | + WasiRights.PATH_RENAME_SOURCE | + WasiRights.PATH_RENAME_TARGET | + WasiRights.PATH_FILESTAT_GET | + WasiRights.PATH_FILESTAT_SET_SIZE | + WasiRights.PATH_FILESTAT_SET_TIMES | + WasiRights.FD_FILESTAT_GET | + WasiRights.FD_FILESTAT_SET_TIMES | + WasiRights.PATH_SYMLINK | + WasiRights.PATH_UNLINK_FILE | + WasiRights.PATH_REMOVE_DIRECTORY | + WasiRights.POLL_FD_READWRITE; +const DIRECTORY_INHERITING = DIRECTORY_BASE | REGULAR_FILE_BASE; +const SOCKET_BASE = (WasiRights.FD_READ | + WasiRights.FD_FDSTAT_SET_FLAGS | + WasiRights.FD_WRITE | + WasiRights.FD_FILESTAT_GET | + WasiRights.POLL_FD_READWRITE | + WasiRights.SOCK_SHUTDOWN); +const SOCKET_INHERITING = RIGHTS_ALL; +const TTY_BASE = WasiRights.FD_READ | + WasiRights.FD_FDSTAT_SET_FLAGS | + WasiRights.FD_WRITE | + WasiRights.FD_FILESTAT_GET | + WasiRights.POLL_FD_READWRITE; +const TTY_INHERITING = /*#__PURE__*/ BigInt(0); +function getRights(stdio, fd, flags, type) { + const ret = { + base: BigInt(0), + inheriting: BigInt(0) + }; + if (type === 0 /* WasiFileType.UNKNOWN */) { + throw new WasiError('Unknown file type', 28 /* WasiErrno.EINVAL */); + } + switch (type) { + case 4 /* WasiFileType.REGULAR_FILE */: + ret.base = REGULAR_FILE_BASE; + ret.inheriting = REGULAR_FILE_INHERITING; + break; + case 3 /* WasiFileType.DIRECTORY */: + ret.base = DIRECTORY_BASE; + ret.inheriting = DIRECTORY_INHERITING; + break; + case 6 /* WasiFileType.SOCKET_STREAM */: + case 5 /* WasiFileType.SOCKET_DGRAM */: + ret.base = SOCKET_BASE; + ret.inheriting = SOCKET_INHERITING; + break; + case 2 /* WasiFileType.CHARACTER_DEVICE */: + if (stdio.indexOf(fd) !== -1) { + ret.base = TTY_BASE; + ret.inheriting = TTY_INHERITING; + } + else { + ret.base = CHARACTER_DEVICE_BASE; + ret.inheriting = CHARACTER_DEVICE_INHERITING; + } + break; + case 1 /* WasiFileType.BLOCK_DEVICE */: + ret.base = BLOCK_DEVICE_BASE; + ret.inheriting = BLOCK_DEVICE_INHERITING; + break; + default: + ret.base = BigInt(0); + ret.inheriting = BigInt(0); + } + /* Disable read/write bits depending on access mode. */ + const read_or_write_only = flags & (0 | 1 | 2); + if (read_or_write_only === 0) { + ret.base &= ~WasiRights.FD_WRITE; + } + else if (read_or_write_only === 1) { + ret.base &= ~WasiRights.FD_READ; + } + return ret; +} + +function concatBuffer(buffers, size) { + let total = 0; + { + for (let i = 0; i < buffers.length; i++) { + const buffer = buffers[i]; + total += buffer.length; + } + } + let pos = 0; + const ret = new Uint8Array(total); + for (let i = 0; i < buffers.length; i++) { + const buffer = buffers[i]; + ret.set(buffer, pos); + pos += buffer.length; + } + return ret; +} +class FileDescriptor { + constructor(id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen) { + this.id = id; + this.fd = fd; + this.path = path; + this.realPath = realPath; + this.type = type; + this.rightsBase = rightsBase; + this.rightsInheriting = rightsInheriting; + this.preopen = preopen; + this.pos = BigInt(0); + this.size = BigInt(0); + } + seek(offset, whence) { + if (whence === 0 /* WasiWhence.SET */) { + this.pos = BigInt(offset); + } + else if (whence === 1 /* WasiWhence.CUR */) { + this.pos += BigInt(offset); + } + else if (whence === 2 /* WasiWhence.END */) { + this.pos = BigInt(this.size) - BigInt(offset); + } + else { + throw new WasiError('Unknown whence', 29 /* WasiErrno.EIO */); + } + return this.pos; + } +} +class StandardOutput extends FileDescriptor { + constructor(log, id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen) { + super(id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen); + this._log = log; + this._buf = null; + } + write(buffer) { + const originalBuffer = buffer; + if (this._buf) { + buffer = concatBuffer([this._buf, buffer]); + this._buf = null; + } + if (buffer.indexOf(10) === -1) { + this._buf = buffer; + return originalBuffer.byteLength; + } + let written = 0; + let lastBegin = 0; + let index; + while ((index = buffer.indexOf(10, written)) !== -1) { + const str = new TextDecoder().decode(buffer.subarray(lastBegin, index)); + this._log(str); + written += index - lastBegin + 1; + lastBegin = index + 1; + } + if (written < buffer.length) { + this._buf = buffer.slice(written); + } + return originalBuffer.byteLength; + } +} +function toFileType(stat) { + if (stat.isBlockDevice()) + return 1 /* WasiFileType.BLOCK_DEVICE */; + if (stat.isCharacterDevice()) + return 2 /* WasiFileType.CHARACTER_DEVICE */; + if (stat.isDirectory()) + return 3 /* WasiFileType.DIRECTORY */; + if (stat.isSocket()) + return 6 /* WasiFileType.SOCKET_STREAM */; + if (stat.isFile()) + return 4 /* WasiFileType.REGULAR_FILE */; + if (stat.isSymbolicLink()) + return 7 /* WasiFileType.SYMBOLIC_LINK */; + return 0 /* WasiFileType.UNKNOWN */; +} +function toFileStat(view, buf, stat) { + view.setBigUint64(buf, stat.dev, true); + view.setBigUint64(buf + 8, stat.ino, true); + view.setBigUint64(buf + 16, BigInt(toFileType(stat)), true); + view.setBigUint64(buf + 24, stat.nlink, true); + view.setBigUint64(buf + 32, stat.size, true); + view.setBigUint64(buf + 40, stat.atimeMs * BigInt(1000000), true); + view.setBigUint64(buf + 48, stat.mtimeMs * BigInt(1000000), true); + view.setBigUint64(buf + 56, stat.ctimeMs * BigInt(1000000), true); +} +class FileDescriptorTable { + constructor(options) { + this.used = 0; + this.size = options.size; + this.fds = Array(options.size); + this.stdio = [options.in, options.out, options.err]; + this.print = options.print; + this.printErr = options.printErr; + this.insertStdio(options.in, 0, ''); + this.insertStdio(options.out, 1, ''); + this.insertStdio(options.err, 2, ''); + } + insertStdio(fd, expected, name) { + const type = 2 /* WasiFileType.CHARACTER_DEVICE */; + const { base, inheriting } = getRights(this.stdio, fd, 2 /* FileControlFlag.O_RDWR */, type); + const wrap = this.insert(fd, name, name, type, base, inheriting, 0); + if (wrap.id !== expected) { + throw new WasiError(`id: ${wrap.id} !== expected: ${expected}`, 8 /* WasiErrno.EBADF */); + } + return wrap; + } + insert(fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen) { + var _a, _b; + let index = -1; + if (this.used >= this.size) { + const newSize = this.size * 2; + this.fds.length = newSize; + index = this.size; + this.size = newSize; + } + else { + for (let i = 0; i < this.size; ++i) { + if (this.fds[i] == null) { + index = i; + break; + } + } + } + let entry; + if (mappedPath === '') { + entry = new StandardOutput((_a = this.print) !== null && _a !== void 0 ? _a : console.log, index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen); + } + else if (mappedPath === '') { + entry = new StandardOutput((_b = this.printErr) !== null && _b !== void 0 ? _b : console.error, index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen); + } + else { + entry = new FileDescriptor(index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen); + } + this.fds[index] = entry; + this.used++; + return entry; + } + get(id, base, inheriting) { + if (id >= this.size) { + throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */); + } + const entry = this.fds[id]; + if (!entry || entry.id !== id) { + throw new WasiError('Bad file descriptor', 8 /* WasiErrno.EBADF */); + } + /* Validate that the fd has the necessary rights. */ + if ((~entry.rightsBase & base) !== BigInt(0) || (~entry.rightsInheriting & inheriting) !== BigInt(0)) { + throw new WasiError('Capabilities insufficient', 76 /* WasiErrno.ENOTCAPABLE */); + } + return entry; + } + remove(id) { + if (id >= this.size) { + throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */); + } + const entry = this.fds[id]; + if (!entry || entry.id !== id) { + throw new WasiError('Bad file descriptor', 8 /* WasiErrno.EBADF */); + } + this.fds[id] = undefined; + this.used--; + } +} +class SyncTable extends FileDescriptorTable { + constructor(options) { + super(options); + this.fs = options.fs; + } + getFileTypeByFd(fd) { + const stats = this.fs.fstatSync(fd, { bigint: true }); + return toFileType(stats); + } + insertPreopen(fd, mappedPath, realPath) { + const type = this.getFileTypeByFd(fd); + if (type !== 3 /* WasiFileType.DIRECTORY */) { + throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, 54 /* WasiErrno.ENOTDIR */); + } + const result = getRights(this.stdio, fd, 0, type); + return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1); + } + renumber(dst, src) { + if (dst === src) + return; + if (dst >= this.size || src >= this.size) { + throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */); + } + const dstEntry = this.fds[dst]; + const srcEntry = this.fds[src]; + if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) { + throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */); + } + this.fs.closeSync(dstEntry.fd); + this.fds[dst] = this.fds[src]; + this.fds[dst].id = dst; + this.fds[src] = undefined; + this.used--; + } +} +class AsyncTable extends FileDescriptorTable { + // eslint-disable-next-line @typescript-eslint/no-useless-constructor + constructor(options) { + super(options); + } + async getFileTypeByFd(fd) { + const stats = await fd.stat({ bigint: true }); + return toFileType(stats); + } + async insertPreopen(fd, mappedPath, realPath) { + const type = await this.getFileTypeByFd(fd); + if (type !== 3 /* WasiFileType.DIRECTORY */) { + throw new WasiError(`Preopen not dir: ["${mappedPath}", "${realPath}"]`, 54 /* WasiErrno.ENOTDIR */); + } + const result = getRights(this.stdio, fd.fd, 0, type); + return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1); + } + async renumber(dst, src) { + if (dst === src) + return; + if (dst >= this.size || src >= this.size) { + throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */); + } + const dstEntry = this.fds[dst]; + const srcEntry = this.fds[src]; + if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) { + throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */); + } + await dstEntry.fd.close(); + this.fds[dst] = this.fds[src]; + this.fds[dst].id = dst; + this.fds[src] = undefined; + this.used--; + } +} + +/** @public */ +const WebAssemblyMemory = /*#__PURE__*/ (function () { return _WebAssembly.Memory; })(); +/** @public */ +class Memory extends WebAssemblyMemory { + // eslint-disable-next-line @typescript-eslint/no-useless-constructor + constructor(descriptor) { + super(descriptor); + } + get HEAP8() { return new Int8Array(super.buffer); } + get HEAPU8() { return new Uint8Array(super.buffer); } + get HEAP16() { return new Int16Array(super.buffer); } + get HEAPU16() { return new Uint16Array(super.buffer); } + get HEAP32() { return new Int32Array(super.buffer); } + get HEAPU32() { return new Uint32Array(super.buffer); } + get HEAP64() { return new BigInt64Array(super.buffer); } + get HEAPU64() { return new BigUint64Array(super.buffer); } + get HEAPF32() { return new Float32Array(super.buffer); } + get HEAPF64() { return new Float64Array(super.buffer); } + get view() { return new DataView(super.buffer); } +} +/** @public */ +function extendMemory(memory) { + if (Object.getPrototypeOf(memory) === _WebAssembly.Memory.prototype) { + Object.setPrototypeOf(memory, Memory.prototype); + } + return memory; +} + +function checkWebAssemblyFunction() { + const WebAssemblyFunction = _WebAssembly.Function; + if (typeof WebAssemblyFunction !== 'function') { + throw new Error('WebAssembly.Function is not supported in this environment.' + + ' If you are using V8 based browser like Chrome, try to specify' + + ' --js-flags="--wasm-staging --experimental-wasm-stack-switching"'); + } + return WebAssemblyFunction; +} +/** @public */ +function wrapAsyncImport(f, parameterType, returnType) { + const WebAssemblyFunction = checkWebAssemblyFunction(); + if (typeof f !== 'function') { + throw new TypeError('Function required'); + } + const parameters = parameterType.slice(0); + parameters.unshift('externref'); + return new WebAssemblyFunction({ parameters, results: returnType }, f, { suspending: 'first' }); +} + +function copyMemory(targets, src) { + if (targets.length === 0 || src.length === 0) + return 0; + let copied = 0; + let left = src.length - copied; + for (let i = 0; i < targets.length; ++i) { + const target = targets[i]; + if (left < target.length) { + target.set(src.subarray(copied, copied + left), 0); + copied += left; + left = 0; + return copied; + } + target.set(src.subarray(copied, copied + target.length), 0); + copied += target.length; + left -= target.length; + } + return copied; +} +const _memory = new WeakMap(); +const _wasi = new WeakMap(); +const _fs = new WeakMap(); +function getMemory(wasi) { + return _memory.get(wasi); +} +function getFs(wasi) { + const fs = _fs.get(wasi); + if (!fs) + throw new Error('filesystem is unavailable'); + return fs; +} +function handleError(err) { + if (err instanceof WasiError) { + return err.errno; + } + switch (err.code) { + case 'ENOENT': return 44 /* WasiErrno.ENOENT */; + case 'EBADF': return 8 /* WasiErrno.EBADF */; + case 'EINVAL': return 28 /* WasiErrno.EINVAL */; + case 'EPERM': return 63 /* WasiErrno.EPERM */; + case 'EPROTO': return 65 /* WasiErrno.EPROTO */; + case 'EEXIST': return 20 /* WasiErrno.EEXIST */; + case 'ENOTDIR': return 54 /* WasiErrno.ENOTDIR */; + case 'EMFILE': return 33 /* WasiErrno.EMFILE */; + case 'EACCES': return 2 /* WasiErrno.EACCES */; + case 'EISDIR': return 31 /* WasiErrno.EISDIR */; + case 'ENOTEMPTY': return 55 /* WasiErrno.ENOTEMPTY */; + case 'ENOSYS': return 52 /* WasiErrno.ENOSYS */; + } + throw err; +} +function defineName(name, f) { + Object.defineProperty(f, 'name', { value: name }); + return f; +} +function syscallWrap(self, name, f) { + return defineName(name, function () { + let r; + try { + r = f.apply(self, arguments); + } + catch (err) { + return handleError(err); + } + if (isPromiseLike(r)) { + return r.then(_ => _, handleError); + } + return r; + }); +} +function resolvePathSync(fs, fileDescriptor, path, flags) { + let resolvedPath = resolve(fileDescriptor.realPath, path); + if ((flags & 1) === 1) { + try { + resolvedPath = fs.readlinkSync(resolvedPath); + } + catch (err) { + if (err.code !== 'EINVAL' && err.code !== 'ENOENT') { + throw err; + } + } + } + return resolvedPath; +} +async function resolvePathAsync(fs, fileDescriptor, path, flags) { + let resolvedPath = resolve(fileDescriptor.realPath, path); + if ((flags & 1) === 1) { + try { + resolvedPath = await fs.promises.readlink(resolvedPath); + } + catch (err) { + if (err.code !== 'EINVAL' && err.code !== 'ENOENT') { + throw err; + } + } + } + return resolvedPath; +} +// eslint-disable-next-line spaced-comment +const encoder = /*#__PURE__*/ new TextEncoder(); +// eslint-disable-next-line spaced-comment +const decoder = /*#__PURE__*/ new TextDecoder(); +const INT64_MAX = (BigInt(1) << BigInt(63)) - BigInt(1); +function readStdin() { + const value = window.prompt(); + if (value === null) + return new Uint8Array(); + const buffer = new TextEncoder().encode(value + '\n'); + return buffer; +} +function validateFstFlagsOrReturn(flags) { + return (Boolean((flags) & ~(1 /* WasiFstFlag.SET_ATIM */ | 2 /* WasiFstFlag.SET_ATIM_NOW */ | + 4 /* WasiFstFlag.SET_MTIM */ | 8 /* WasiFstFlag.SET_MTIM_NOW */)) || + ((flags) & (1 /* WasiFstFlag.SET_ATIM */ | 2 /* WasiFstFlag.SET_ATIM_NOW */)) === + (1 /* WasiFstFlag.SET_ATIM */ | 2 /* WasiFstFlag.SET_ATIM_NOW */) || + ((flags) & (4 /* WasiFstFlag.SET_MTIM */ | 8 /* WasiFstFlag.SET_MTIM_NOW */)) === + (4 /* WasiFstFlag.SET_MTIM */ | 8 /* WasiFstFlag.SET_MTIM_NOW */)); +} +class WASI$1 { + constructor(args, env, fds, asyncFs, fs, asyncify) { + this.args_get = syscallWrap(this, 'args_get', function (argv, argv_buf) { + argv = Number(argv); + argv_buf = Number(argv_buf); + if (argv === 0 || argv_buf === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const args = wasi.args; + for (let i = 0; i < args.length; ++i) { + const arg = args[i]; + view.setInt32(argv, argv_buf, true); + argv += 4; + const data = encoder.encode(arg + '\0'); + HEAPU8.set(data, argv_buf); + argv_buf += data.length; + } + return 0 /* WasiErrno.ESUCCESS */; + }); + this.args_sizes_get = syscallWrap(this, 'args_sizes_get', function (argc, argv_buf_size) { + argc = Number(argc); + argv_buf_size = Number(argv_buf_size); + if (argc === 0 || argv_buf_size === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { view } = getMemory(this); + const wasi = _wasi.get(this); + const args = wasi.args; + view.setUint32(argc, args.length, true); + view.setUint32(argv_buf_size, encoder.encode(args.join('\0') + '\0').length, true); + return 0 /* WasiErrno.ESUCCESS */; + }); + this.environ_get = syscallWrap(this, 'environ_get', function (environ, environ_buf) { + environ = Number(environ); + environ_buf = Number(environ_buf); + if (environ === 0 || environ_buf === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const env = wasi.env; + for (let i = 0; i < env.length; ++i) { + const pair = env[i]; + view.setInt32(environ, environ_buf, true); + environ += 4; + const data = encoder.encode(pair + '\0'); + HEAPU8.set(data, environ_buf); + environ_buf += data.length; + } + return 0 /* WasiErrno.ESUCCESS */; + }); + this.environ_sizes_get = syscallWrap(this, 'environ_sizes_get', function (len, buflen) { + len = Number(len); + buflen = Number(buflen); + if (len === 0 || buflen === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { view } = getMemory(this); + const wasi = _wasi.get(this); + view.setUint32(len, wasi.env.length, true); + view.setUint32(buflen, encoder.encode(wasi.env.join('\0') + '\0').length, true); + return 0 /* WasiErrno.ESUCCESS */; + }); + this.clock_res_get = syscallWrap(this, 'clock_res_get', function (id, resolution) { + resolution = Number(resolution); + if (resolution === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { view } = getMemory(this); + switch (id) { + case 0 /* WasiClockid.REALTIME */: + view.setBigUint64(resolution, BigInt(1000000), true); + return 0 /* WasiErrno.ESUCCESS */; + case 1 /* WasiClockid.MONOTONIC */: + case 2 /* WasiClockid.PROCESS_CPUTIME_ID */: + case 3 /* WasiClockid.THREAD_CPUTIME_ID */: + view.setBigUint64(resolution, BigInt(1000), true); + return 0 /* WasiErrno.ESUCCESS */; + default: return 28 /* WasiErrno.EINVAL */; + } + }); + this.clock_time_get = syscallWrap(this, 'clock_time_get', function (id, _percision, time) { + time = Number(time); + if (time === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { view } = getMemory(this); + switch (id) { + case 0 /* WasiClockid.REALTIME */: + view.setBigUint64(time, BigInt(Date.now()) * BigInt(1000000), true); + return 0 /* WasiErrno.ESUCCESS */; + case 1 /* WasiClockid.MONOTONIC */: + case 2 /* WasiClockid.PROCESS_CPUTIME_ID */: + case 3 /* WasiClockid.THREAD_CPUTIME_ID */: { + const t = performance.now(); + const s = Math.trunc(t); + const ms = Math.floor((t - s) * 1000); + const result = BigInt(s) * BigInt(1000000000) + BigInt(ms) * BigInt(1000000); + view.setBigUint64(time, result, true); + return 0 /* WasiErrno.ESUCCESS */; + } + default: return 28 /* WasiErrno.EINVAL */; + } + }); + this.fd_advise = syscallWrap(this, 'fd_advise', function (_fd, _offset, _len, _advice) { + return 52 /* WasiErrno.ENOSYS */; + }); + this.fd_fdstat_get = syscallWrap(this, 'fd_fdstat_get', function (fd, fdstat) { + fdstat = Number(fdstat); + if (fdstat === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0)); + const { view } = getMemory(this); + view.setUint16(fdstat, fileDescriptor.type, true); + view.setUint16(fdstat + 2, 0, true); + view.setBigUint64(fdstat + 8, fileDescriptor.rightsBase, true); + view.setBigUint64(fdstat + 16, fileDescriptor.rightsInheriting, true); + return 0 /* WasiErrno.ESUCCESS */; + }); + this.fd_fdstat_set_flags = syscallWrap(this, 'fd_fdstat_set_flags', function (_fd, _flags) { + return 52 /* WasiErrno.ENOSYS */; + }); + this.fd_fdstat_set_rights = syscallWrap(this, 'fd_fdstat_set_rights', function (fd, rightsBase, rightsInheriting) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0)); + if ((rightsBase | fileDescriptor.rightsBase) > fileDescriptor.rightsBase) { + return 76 /* WasiErrno.ENOTCAPABLE */; + } + if ((rightsInheriting | fileDescriptor.rightsInheriting) > + fileDescriptor.rightsInheriting) { + return 76 /* WasiErrno.ENOTCAPABLE */; + } + fileDescriptor.rightsBase = rightsBase; + fileDescriptor.rightsInheriting = rightsInheriting; + return 0 /* WasiErrno.ESUCCESS */; + }); + this.fd_prestat_get = syscallWrap(this, 'fd_prestat_get', function (fd, prestat) { + prestat = Number(prestat); + if (prestat === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const wasi = _wasi.get(this); + let fileDescriptor; + try { + fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0)); + } + catch (err) { + if (err instanceof WasiError) + return err.errno; + throw err; + } + if (fileDescriptor.preopen !== 1) + return 28 /* WasiErrno.EINVAL */; + const { view } = getMemory(this); + // preopen type is dir(0) + view.setUint32(prestat, 0, true); + view.setUint32(prestat + 4, encoder.encode(fileDescriptor.path).length, true); + return 0 /* WasiErrno.ESUCCESS */; + }); + this.fd_prestat_dir_name = syscallWrap(this, 'fd_prestat_dir_name', function (fd, path, path_len) { + path = Number(path); + path_len = Number(path_len); + if (path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0)); + if (fileDescriptor.preopen !== 1) + return 8 /* WasiErrno.EBADF */; + const buffer = encoder.encode(fileDescriptor.path); + const size = buffer.length; + if (size > path_len) + return 42 /* WasiErrno.ENOBUFS */; + const { HEAPU8 } = getMemory(this); + HEAPU8.set(buffer, path); + return 0 /* WasiErrno.ESUCCESS */; + }); + this.fd_seek = syscallWrap(this, 'fd_seek', function (fd, offset, whence, newOffset) { + newOffset = Number(newOffset); + if (newOffset === 0) { + return 28 /* WasiErrno.EINVAL */; + } + if (fd === 0 || fd === 1 || fd === 2) + return 0 /* WasiErrno.ESUCCESS */; + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_SEEK, BigInt(0)); + const r = fileDescriptor.seek(offset, whence); + const { view } = getMemory(this); + view.setBigUint64(newOffset, r, true); + return 0 /* WasiErrno.ESUCCESS */; + }); + this.fd_tell = syscallWrap(this, 'fd_tell', function (fd, offset) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_TELL, BigInt(0)); + const pos = BigInt(fileDescriptor.pos); + const { view } = getMemory(this); + view.setBigUint64(Number(offset), pos, true); + return 0 /* WasiErrno.ESUCCESS */; + }); + this.poll_oneoff = syscallWrap(this, 'poll_oneoff', function (in_ptr, out_ptr, nsubscriptions, nevents) { + in_ptr = Number(in_ptr); + out_ptr = Number(out_ptr); + nevents = Number(nevents); + nsubscriptions = Number(nsubscriptions); + nsubscriptions = nsubscriptions >>> 0; + if (in_ptr === 0 || out_ptr === 0 || nsubscriptions === 0 || nevents === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { view } = getMemory(this); + view.setUint32(nevents, 0, true); + let i = 0; + let timer_userdata = BigInt(0); + let cur_timeout = BigInt(0); + let has_timeout = 0; + let min_timeout = BigInt(0); + let sub; + const subscriptions = Array(nsubscriptions); + for (i = 0; i < nsubscriptions; i++) { + sub = in_ptr + i * 48; + const userdata = view.getBigUint64(sub, true); + const type = view.getUint8(sub + 8); + const clockIdOrFd = view.getUint32(sub + 16, true); + const timeout = view.getBigUint64(sub + 24, true); + const precision = view.getBigUint64(sub + 32, true); + const flags = view.getUint16(sub + 40, true); + subscriptions[i] = { + userdata, + type, + u: { + clock: { + clock_id: clockIdOrFd, + timeout, + precision, + flags + }, + fd_readwrite: { + fd: clockIdOrFd + } + } + }; + } + const fdevents = []; + for (i = 0; i < nsubscriptions; i++) { + sub = subscriptions[i]; + switch (sub.type) { + case 0 /* WasiEventType.CLOCK */: { + if (sub.u.clock.flags === 1 /* WasiSubclockflags.ABSTIME */) { + /* Convert absolute time to relative delay. */ + const now = BigInt(Date.now()) * BigInt(1000000); + cur_timeout = sub.u.clock.timeout - now; + } + else { + cur_timeout = sub.u.clock.timeout; + } + if (has_timeout === 0 || cur_timeout < min_timeout) { + min_timeout = cur_timeout; + timer_userdata = sub.userdata; + has_timeout = 1; + } + break; + } + case 1 /* WasiEventType.FD_READ */: + case 2 /* WasiEventType.FD_WRITE */: + fdevents.push(sub); + break; + default: return 28 /* WasiErrno.EINVAL */; + } + } + if (fdevents.length > 0) { + for (i = 0; i < fdevents.length; i++) { + const fdevent = fdevents[i]; + const event = out_ptr + 32 * i; + view.setBigUint64(event, fdevent.userdata, true); + view.setUint32(event + 8, 52 /* WasiErrno.ENOSYS */, true); + view.setUint32(event + 12, fdevent.type, true); + view.setBigUint64(event + 16, BigInt(0), true); + view.setUint16(event + 24, 0, true); + view.setUint32(nevents, 1, true); + } + view.setUint32(nevents, fdevents.length, true); + return 0 /* WasiErrno.ESUCCESS */; + } + if (has_timeout) { + Number(min_timeout / BigInt(1000000)); + // } else { + // const buf = new SharedArrayBuffer(4) + // const arr = new Int32Array(buf) + // postMsg({ + // __tybys_wasm_util_wasi__: { + // type: 'set-timeout', + // payload: { + // buffer: buf, + // delay + // } + // } + // }) + // Atomics.wait(arr, 0, 0) + // } + const event = out_ptr; + view.setBigUint64(event, timer_userdata, true); + view.setUint32(event + 8, 0 /* WasiErrno.ESUCCESS */, true); + view.setUint32(event + 12, 0 /* WasiEventType.CLOCK */, true); + view.setUint32(nevents, 1, true); + } + return 0 /* WasiErrno.ESUCCESS */; + }); + this.proc_exit = syscallWrap(this, 'proc_exit', function (rval) { + return 0 /* WasiErrno.ESUCCESS */; + }); + this.proc_raise = syscallWrap(this, 'proc_raise', function (_sig) { + return 52 /* WasiErrno.ENOSYS */; + }); + this.sched_yield = syscallWrap(this, 'sched_yield', function () { + return 0 /* WasiErrno.ESUCCESS */; + }); + this.random_get = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function' + ? syscallWrap(this, 'random_get', function (buf, buf_len) { + buf = Number(buf); + if (buf === 0) { + return 28 /* WasiErrno.EINVAL */; + } + buf_len = Number(buf_len); + const { HEAPU8, view } = getMemory(this); + if ((typeof SharedArrayBuffer === 'function' && HEAPU8.buffer instanceof SharedArrayBuffer) || + (Object.prototype.toString.call(HEAPU8.buffer) === '[object SharedArrayBuffer]')) { + for (let i = buf; i < buf + buf_len; ++i) { + view.setUint8(i, Math.floor(Math.random() * 256)); + } + return 0 /* WasiErrno.ESUCCESS */; + } + let pos; + const stride = 65536; + for (pos = 0; pos + stride < buf_len; pos += stride) { + crypto.getRandomValues(HEAPU8.subarray(buf + pos, buf + pos + stride)); + } + crypto.getRandomValues(HEAPU8.subarray(buf + pos, buf + buf_len)); + return 0 /* WasiErrno.ESUCCESS */; + }) + : syscallWrap(this, 'random_get', function (buf, buf_len) { + buf = Number(buf); + if (buf === 0) { + return 28 /* WasiErrno.EINVAL */; + } + buf_len = Number(buf_len); + const { view } = getMemory(this); + for (let i = buf; i < buf + buf_len; ++i) { + view.setUint8(i, Math.floor(Math.random() * 256)); + } + return 0 /* WasiErrno.ESUCCESS */; + }); + this.sock_recv = syscallWrap(this, 'sock_recv', function () { + return 58 /* WasiErrno.ENOTSUP */; + }); + this.sock_send = syscallWrap(this, 'sock_send', function () { + return 58 /* WasiErrno.ENOTSUP */; + }); + this.sock_shutdown = syscallWrap(this, 'sock_shutdown', function () { + return 58 /* WasiErrno.ENOTSUP */; + }); + this.sock_accept = syscallWrap(this, 'sock_accept', function () { + return 58 /* WasiErrno.ENOTSUP */; + }); + _wasi.set(this, { + fds, + args, + env + }); + if (fs) + _fs.set(this, fs); + // eslint-disable-next-line @typescript-eslint/no-this-alias + const _this = this; + function defineImport(name, syncVersion, asyncVersion, parameterType, returnType) { + if (asyncFs) { + if (asyncify) { + _this[name] = asyncify.wrapImportFunction(syscallWrap(_this, name, asyncVersion)); + } + else { + _this[name] = wrapAsyncImport(syscallWrap(_this, name, asyncVersion), parameterType, returnType); + } + } + else { + _this[name] = syscallWrap(_this, name, syncVersion); + } + } + defineImport('fd_allocate', function fd_allocate(fd, offset, len) { + const wasi = _wasi.get(this); + const fs = getFs(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_ALLOCATE, BigInt(0)); + const stat = fs.fstatSync(fileDescriptor.fd, { bigint: true }); + if (stat.size < offset + len) { + fs.ftruncateSync(fileDescriptor.fd, Number(offset + len)); + } + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_allocate(fd, offset, len) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_ALLOCATE, BigInt(0)); + const h = fileDescriptor.fd; + const stat = await h.stat({ bigint: true }); + if (stat.size < offset + len) { + await h.truncate(Number(offset + len)); + } + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i64', 'f64'], ['i32']); + defineImport('fd_close', function fd_close(fd) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0)); + const fs = getFs(this); + fs.closeSync(fileDescriptor.fd); + wasi.fds.remove(fd); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_close(fd) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0)); + await fileDescriptor.fd.close(); + wasi.fds.remove(fd); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32'], ['i32']); + defineImport('fd_datasync', function fd_datasync(fd) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_DATASYNC, BigInt(0)); + const fs = getFs(this); + fs.fdatasyncSync(fileDescriptor.fd); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_datasync(fd) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_DATASYNC, BigInt(0)); + await fileDescriptor.fd.datasync(); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32'], ['i32']); + defineImport('fd_filestat_get', function fd_filestat_get(fd, buf) { + buf = Number(buf); + if (buf === 0) + return 28 /* WasiErrno.EINVAL */; + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_GET, BigInt(0)); + const fs = getFs(this); + const stat = fs.fstatSync(fileDescriptor.fd, { bigint: true }); + const { view } = getMemory(this); + toFileStat(view, buf, stat); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_filestat_get(fd, buf) { + buf = Number(buf); + if (buf === 0) + return 28 /* WasiErrno.EINVAL */; + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_GET, BigInt(0)); + const h = fileDescriptor.fd; + const stat = await h.stat({ bigint: true }); + const { view } = getMemory(this); + toFileStat(view, buf, stat); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32'], ['i32']); + defineImport('fd_filestat_set_size', function fd_filestat_set_size(fd, size) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_SIZE, BigInt(0)); + const fs = getFs(this); + fs.ftruncateSync(fileDescriptor.fd, Number(size)); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_filestat_set_size(fd, size) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_SIZE, BigInt(0)); + const h = fileDescriptor.fd; + await h.truncate(Number(size)); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i64'], ['i32']); + function fdFilestatGetTimes(fd, atim, mtim, flags) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_TIMES, BigInt(0)); + if ((flags & 2 /* WasiFstFlag.SET_ATIM_NOW */) === 2 /* WasiFstFlag.SET_ATIM_NOW */) { + atim = BigInt(Date.now() * 1000000); + } + if ((flags & 8 /* WasiFstFlag.SET_MTIM_NOW */) === 8 /* WasiFstFlag.SET_MTIM_NOW */) { + mtim = BigInt(Date.now() * 1000000); + } + return { fileDescriptor, atim, mtim }; + } + defineImport('fd_filestat_set_times', function fd_filestat_set_times(fd, atim, mtim, flags) { + if (validateFstFlagsOrReturn(flags)) { + return 28 /* WasiErrno.EINVAL */; + } + const { fileDescriptor, atim: atimRes, mtim: mtimRes } = fdFilestatGetTimes.call(this, fd, atim, mtim, flags); + const fs = getFs(this); + fs.futimesSync(fileDescriptor.fd, Number(atimRes), Number(mtimRes)); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_filestat_set_times(fd, atim, mtim, flags) { + if (validateFstFlagsOrReturn(flags)) { + return 28 /* WasiErrno.EINVAL */; + } + const { fileDescriptor, atim: atimRes, mtim: mtimRes } = fdFilestatGetTimes.call(this, fd, atim, mtim, flags); + const h = fileDescriptor.fd; + await h.utimes(Number(atimRes), Number(mtimRes)); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i64', 'i64', 'i32'], ['i32']); + defineImport('fd_pread', function fd_pread(fd, iovs, iovslen, offset, size) { + iovs = Number(iovs); + size = Number(size); + if ((iovs === 0 && iovslen) || size === 0 || offset > INT64_MAX) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ | WasiRights.FD_SEEK, BigInt(0)); + if (!iovslen) { + view.setUint32(size, 0, true); + return 0 /* WasiErrno.ESUCCESS */; + } + let totalSize = 0; + const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => { + const offset = iovs + (i * 8); + const buf = view.getInt32(offset, true); + const bufLen = view.getUint32(offset + 4, true); + totalSize += bufLen; + return HEAPU8.subarray(buf, buf + bufLen); + }); + let nread = 0; + const buffer = (() => { + try { + return new Uint8Array(new SharedArrayBuffer(totalSize)); + } + catch (_) { + return new Uint8Array(totalSize); + } + })(); + buffer._isBuffer = true; + const fs = getFs(this); + const bytesRead = fs.readSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(offset)); + nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0; + view.setUint32(size, nread, true); + return 0 /* WasiErrno.ESUCCESS */; + }, async function (fd, iovs, iovslen, offset, size) { + iovs = Number(iovs); + size = Number(size); + if ((iovs === 0 && iovslen) || size === 0 || offset > INT64_MAX) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ | WasiRights.FD_SEEK, BigInt(0)); + if (!iovslen) { + view.setUint32(size, 0, true); + return 0 /* WasiErrno.ESUCCESS */; + } + let totalSize = 0; + const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => { + const offset = iovs + (i * 8); + const buf = view.getInt32(offset, true); + const bufLen = view.getUint32(offset + 4, true); + totalSize += bufLen; + return HEAPU8.subarray(buf, buf + bufLen); + }); + let nread = 0; + const buffer = new Uint8Array(totalSize); + buffer._isBuffer = true; + const { bytesRead } = await fileDescriptor.fd.read(buffer, 0, buffer.length, Number(offset)); + nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0; + view.setUint32(size, nread, true); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i64', 'i32'], ['i32']); + defineImport('fd_pwrite', function fd_pwrite(fd, iovs, iovslen, offset, size) { + iovs = Number(iovs); + size = Number(size); + if ((iovs === 0 && iovslen) || size === 0 || offset > INT64_MAX) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE | WasiRights.FD_SEEK, BigInt(0)); + if (!iovslen) { + view.setUint32(size, 0, true); + return 0 /* WasiErrno.ESUCCESS */; + } + const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => { + const offset = iovs + (i * 8); + const buf = view.getInt32(offset, true); + const bufLen = view.getUint32(offset + 4, true); + return HEAPU8.subarray(buf, buf + bufLen); + })); + const fs = getFs(this); + const nwritten = fs.writeSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(offset)); + view.setUint32(size, nwritten, true); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_pwrite(fd, iovs, iovslen, offset, size) { + iovs = Number(iovs); + size = Number(size); + if ((iovs === 0 && iovslen) || size === 0 || offset > INT64_MAX) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE | WasiRights.FD_SEEK, BigInt(0)); + if (!iovslen) { + view.setUint32(size, 0, true); + return 0 /* WasiErrno.ESUCCESS */; + } + const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => { + const offset = iovs + (i * 8); + const buf = view.getInt32(offset, true); + const bufLen = view.getUint32(offset + 4, true); + return HEAPU8.subarray(buf, buf + bufLen); + })); + const { bytesWritten } = await fileDescriptor.fd.write(buffer, 0, buffer.length, Number(offset)); + view.setUint32(size, bytesWritten, true); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i64', 'i32'], ['i32']); + defineImport('fd_read', function fd_read(fd, iovs, iovslen, size) { + iovs = Number(iovs); + size = Number(size); + if ((iovs === 0 && iovslen) || size === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ, BigInt(0)); + if (!iovslen) { + view.setUint32(size, 0, true); + return 0 /* WasiErrno.ESUCCESS */; + } + let totalSize = 0; + const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => { + const offset = iovs + (i * 8); + const buf = view.getInt32(offset, true); + const bufLen = view.getUint32(offset + 4, true); + totalSize += bufLen; + return HEAPU8.subarray(buf, buf + bufLen); + }); + let buffer; + let nread = 0; + if (fd === 0) { + if (typeof window === 'undefined' || typeof window.prompt !== 'function') { + return 58 /* WasiErrno.ENOTSUP */; + } + buffer = readStdin(); + nread = buffer ? copyMemory(ioVecs, buffer) : 0; + } + else { + buffer = (() => { + try { + return new Uint8Array(new SharedArrayBuffer(totalSize)); + } + catch (_) { + return new Uint8Array(totalSize); + } + })(); + buffer._isBuffer = true; + const fs = getFs(this); + const bytesRead = fs.readSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(fileDescriptor.pos)); + nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0; + fileDescriptor.pos += BigInt(nread); + } + view.setUint32(size, nread, true); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_read(fd, iovs, iovslen, size) { + iovs = Number(iovs); + size = Number(size); + if ((iovs === 0 && iovslen) || size === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ, BigInt(0)); + if (!iovslen) { + view.setUint32(size, 0, true); + return 0 /* WasiErrno.ESUCCESS */; + } + let totalSize = 0; + const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => { + const offset = iovs + (i * 8); + const buf = view.getInt32(offset, true); + const bufLen = view.getUint32(offset + 4, true); + totalSize += bufLen; + return HEAPU8.subarray(buf, buf + bufLen); + }); + let buffer; + let nread = 0; + if (fd === 0) { + if (typeof window === 'undefined' || typeof window.prompt !== 'function') { + return 58 /* WasiErrno.ENOTSUP */; + } + buffer = readStdin(); + nread = buffer ? copyMemory(ioVecs, buffer) : 0; + } + else { + buffer = new Uint8Array(totalSize); + buffer._isBuffer = true; + const { bytesRead } = await fileDescriptor.fd.read(buffer, 0, buffer.length, Number(fileDescriptor.pos)); + nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0; + fileDescriptor.pos += BigInt(nread); + } + view.setUint32(size, nread, true); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i32'], ['i32']); + defineImport('fd_readdir', function fd_readdir(fd, buf, buf_len, cookie, bufused) { + buf = Number(buf); + buf_len = Number(buf_len); + bufused = Number(bufused); + if (buf === 0 || bufused === 0) + return 0 /* WasiErrno.ESUCCESS */; + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READDIR, BigInt(0)); + const fs = getFs(this); + const entries = fs.readdirSync(fileDescriptor.realPath, { withFileTypes: true }); + const { HEAPU8, view } = getMemory(this); + let bufferUsed = 0; + for (let i = Number(cookie); i < entries.length; i++) { + const nameData = encoder.encode(entries[i].name); + const entryInfo = fs.statSync(resolve(fileDescriptor.realPath, entries[i].name), { bigint: true }); + const entryData = new Uint8Array(24 + nameData.byteLength); + const entryView = new DataView(entryData.buffer); + entryView.setBigUint64(0, BigInt(i + 1), true); + entryView.setBigUint64(8, BigInt(entryInfo.ino ? entryInfo.ino : 0), true); + entryView.setUint32(16, nameData.byteLength, true); + let type; + if (entries[i].isFile()) { + type = 4 /* WasiFileType.REGULAR_FILE */; + } + else if (entries[i].isDirectory()) { + type = 3 /* WasiFileType.DIRECTORY */; + } + else if (entries[i].isSymbolicLink()) { + type = 7 /* WasiFileType.SYMBOLIC_LINK */; + } + else if (entries[i].isCharacterDevice()) { + type = 2 /* WasiFileType.CHARACTER_DEVICE */; + } + else if (entries[i].isBlockDevice()) { + type = 1 /* WasiFileType.BLOCK_DEVICE */; + } + else if (entries[i].isSocket()) { + type = 6 /* WasiFileType.SOCKET_STREAM */; + } + else { + type = 0 /* WasiFileType.UNKNOWN */; + } + entryView.setUint8(20, type); + entryData.set(nameData, 24); + const data = entryData.slice(0, Math.min(entryData.length, buf_len - bufferUsed)); + HEAPU8.set(data, buf + bufferUsed); + bufferUsed += data.byteLength; + } + view.setUint32(bufused, bufferUsed, true); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_readdir(fd, buf, buf_len, cookie, bufused) { + buf = Number(buf); + buf_len = Number(buf_len); + bufused = Number(bufused); + if (buf === 0 || bufused === 0) + return 0 /* WasiErrno.ESUCCESS */; + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READDIR, BigInt(0)); + const fs = getFs(this); + const entries = await fs.promises.readdir(fileDescriptor.realPath, { withFileTypes: true }); + const { HEAPU8, view } = getMemory(this); + let bufferUsed = 0; + for (let i = Number(cookie); i < entries.length; i++) { + const nameData = encoder.encode(entries[i].name); + const entryInfo = await fs.promises.stat(resolve(fileDescriptor.realPath, entries[i].name), { bigint: true }); + const entryData = new Uint8Array(24 + nameData.byteLength); + const entryView = new DataView(entryData.buffer); + entryView.setBigUint64(0, BigInt(i + 1), true); + entryView.setBigUint64(8, BigInt(entryInfo.ino ? entryInfo.ino : 0), true); + entryView.setUint32(16, nameData.byteLength, true); + let type; + if (entries[i].isFile()) { + type = 4 /* WasiFileType.REGULAR_FILE */; + } + else if (entries[i].isDirectory()) { + type = 3 /* WasiFileType.DIRECTORY */; + } + else if (entries[i].isSymbolicLink()) { + type = 7 /* WasiFileType.SYMBOLIC_LINK */; + } + else if (entries[i].isCharacterDevice()) { + type = 2 /* WasiFileType.CHARACTER_DEVICE */; + } + else if (entries[i].isBlockDevice()) { + type = 1 /* WasiFileType.BLOCK_DEVICE */; + } + else if (entries[i].isSocket()) { + type = 6 /* WasiFileType.SOCKET_STREAM */; + } + else { + type = 0 /* WasiFileType.UNKNOWN */; + } + entryView.setUint8(20, type); + entryData.set(nameData, 24); + const data = entryData.slice(0, Math.min(entryData.length, buf_len - bufferUsed)); + HEAPU8.set(data, buf + bufferUsed); + bufferUsed += data.byteLength; + } + view.setUint32(bufused, bufferUsed, true); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i64', 'i32'], ['i32']); + defineImport('fd_renumber', function fd_renumber(from, to) { + const wasi = _wasi.get(this); + wasi.fds.renumber(to, from); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_renumber(from, to) { + const wasi = _wasi.get(this); + await wasi.fds.renumber(to, from); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32'], ['i32']); + defineImport('fd_sync', function fd_sync(fd) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_SYNC, BigInt(0)); + const fs = getFs(this); + fs.fsyncSync(fileDescriptor.fd); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_sync(fd) { + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_SYNC, BigInt(0)); + await fileDescriptor.fd.sync(); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32'], ['i32']); + defineImport('fd_write', function fd_write(fd, iovs, iovslen, size) { + iovs = Number(iovs); + size = Number(size); + if ((iovs === 0 && iovslen) || size === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE, BigInt(0)); + if (!iovslen) { + view.setUint32(size, 0, true); + return 0 /* WasiErrno.ESUCCESS */; + } + const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => { + const offset = iovs + (i * 8); + const buf = view.getInt32(offset, true); + const bufLen = view.getUint32(offset + 4, true); + return HEAPU8.subarray(buf, buf + bufLen); + })); + let nwritten; + if (fd === 1 || fd === 2) { + nwritten = fileDescriptor.write(buffer); + } + else { + const fs = getFs(this); + nwritten = fs.writeSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(fileDescriptor.pos)); + fileDescriptor.pos += BigInt(nwritten); + } + view.setUint32(size, nwritten, true); + return 0 /* WasiErrno.ESUCCESS */; + }, async function fd_write(fd, iovs, iovslen, size) { + iovs = Number(iovs); + size = Number(size); + if ((iovs === 0 && iovslen) || size === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE, BigInt(0)); + if (!iovslen) { + view.setUint32(size, 0, true); + return 0 /* WasiErrno.ESUCCESS */; + } + const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => { + const offset = iovs + (i * 8); + const buf = view.getInt32(offset, true); + const bufLen = view.getUint32(offset + 4, true); + return HEAPU8.subarray(buf, buf + bufLen); + })); + let nwritten; + if (fd === 1 || fd === 2) { + nwritten = fileDescriptor.write(buffer); + } + else { + nwritten = await (await (fileDescriptor.fd.write(buffer, 0, buffer.length, Number(fileDescriptor.pos)))).bytesWritten; + fileDescriptor.pos += BigInt(nwritten); + } + view.setUint32(size, nwritten, true); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i32'], ['i32']); + defineImport('path_create_directory', function path_create_directory(fd, path, path_len) { + path = Number(path); + path_len = Number(path_len); + if (path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8 } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_CREATE_DIRECTORY, BigInt(0)); + let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + pathString = resolve(fileDescriptor.realPath, pathString); + const fs = getFs(this); + fs.mkdirSync(pathString); + return 0 /* WasiErrno.ESUCCESS */; + }, async function path_create_directory(fd, path, path_len) { + path = Number(path); + path_len = Number(path_len); + if (path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8 } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_CREATE_DIRECTORY, BigInt(0)); + let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + pathString = resolve(fileDescriptor.realPath, pathString); + const fs = getFs(this); + await fs.promises.mkdir(pathString); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32'], ['i32']); + defineImport('path_filestat_get', function path_filestat_get(fd, flags, path, path_len, filestat) { + path = Number(path); + path_len = Number(path_len); + filestat = Number(filestat); + if (path === 0 || filestat === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_GET, BigInt(0)); + let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + const fs = getFs(this); + pathString = resolve(fileDescriptor.realPath, pathString); + let stat; + if ((flags & 1) === 1) { + stat = fs.statSync(pathString, { bigint: true }); + } + else { + stat = fs.lstatSync(pathString, { bigint: true }); + } + toFileStat(view, filestat, stat); + return 0 /* WasiErrno.ESUCCESS */; + }, async function path_filestat_get(fd, flags, path, path_len, filestat) { + path = Number(path); + path_len = Number(path_len); + filestat = Number(filestat); + if (path === 0 || filestat === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_GET, BigInt(0)); + let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + const fs = getFs(this); + pathString = resolve(fileDescriptor.realPath, pathString); + let stat; + if ((flags & 1) === 1) { + stat = await fs.promises.stat(pathString, { bigint: true }); + } + else { + stat = await fs.promises.lstat(pathString, { bigint: true }); + } + toFileStat(view, filestat, stat); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i32', 'i32'], ['i32']); + defineImport('path_filestat_set_times', function path_filestat_set_times(fd, flags, path, path_len, atim, mtim, fst_flags) { + path = Number(path); + path_len = Number(path_len); + if (path === 0) + return 28 /* WasiErrno.EINVAL */; + const { HEAPU8 } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_SET_TIMES, BigInt(0)); + if (validateFstFlagsOrReturn(fst_flags)) { + return 28 /* WasiErrno.EINVAL */; + } + const fs = getFs(this); + const resolvedPath = resolvePathSync(fs, fileDescriptor, decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)), flags); + if ((fst_flags & 2 /* WasiFstFlag.SET_ATIM_NOW */) === 2 /* WasiFstFlag.SET_ATIM_NOW */) { + atim = BigInt(Date.now() * 1000000); + } + if ((fst_flags & 8 /* WasiFstFlag.SET_MTIM_NOW */) === 8 /* WasiFstFlag.SET_MTIM_NOW */) { + mtim = BigInt(Date.now() * 1000000); + } + fs.utimesSync(resolvedPath, Number(atim), Number(mtim)); + return 0 /* WasiErrno.ESUCCESS */; + }, async function path_filestat_set_times(fd, flags, path, path_len, atim, mtim, fst_flags) { + path = Number(path); + path_len = Number(path_len); + if (path === 0) + return 28 /* WasiErrno.EINVAL */; + const { HEAPU8 } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_SET_TIMES, BigInt(0)); + if (validateFstFlagsOrReturn(fst_flags)) { + return 28 /* WasiErrno.EINVAL */; + } + const fs = getFs(this); + const resolvedPath = await resolvePathAsync(fs, fileDescriptor, decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)), flags); + if ((fst_flags & 2 /* WasiFstFlag.SET_ATIM_NOW */) === 2 /* WasiFstFlag.SET_ATIM_NOW */) { + atim = BigInt(Date.now() * 1000000); + } + if ((fst_flags & 8 /* WasiFstFlag.SET_MTIM_NOW */) === 8 /* WasiFstFlag.SET_MTIM_NOW */) { + mtim = BigInt(Date.now() * 1000000); + } + await fs.promises.utimes(resolvedPath, Number(atim), Number(mtim)); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i32', 'i64', 'i64', 'i32'], ['i32']); + defineImport('path_link', function path_link(old_fd, old_flags, old_path, old_path_len, new_fd, new_path, new_path_len) { + old_path = Number(old_path); + old_path_len = Number(old_path_len); + new_path = Number(new_path); + new_path_len = Number(new_path_len); + if (old_path === 0 || new_path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const wasi = _wasi.get(this); + let oldWrap; + let newWrap; + if (old_fd === new_fd) { + oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE | WasiRights.PATH_LINK_TARGET, BigInt(0)); + } + else { + oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE, BigInt(0)); + newWrap = wasi.fds.get(new_fd, WasiRights.PATH_LINK_TARGET, BigInt(0)); + } + const { HEAPU8 } = getMemory(this); + const fs = getFs(this); + const resolvedOldPath = resolvePathSync(fs, oldWrap, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)), old_flags); + const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len))); + fs.linkSync(resolvedOldPath, resolvedNewPath); + return 0 /* WasiErrno.ESUCCESS */; + }, async function path_link(old_fd, old_flags, old_path, old_path_len, new_fd, new_path, new_path_len) { + old_path = Number(old_path); + old_path_len = Number(old_path_len); + new_path = Number(new_path); + new_path_len = Number(new_path_len); + if (old_path === 0 || new_path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const wasi = _wasi.get(this); + let oldWrap; + let newWrap; + if (old_fd === new_fd) { + oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE | WasiRights.PATH_LINK_TARGET, BigInt(0)); + } + else { + oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE, BigInt(0)); + newWrap = wasi.fds.get(new_fd, WasiRights.PATH_LINK_TARGET, BigInt(0)); + } + const { HEAPU8 } = getMemory(this); + const fs = getFs(this); + const resolvedOldPath = await resolvePathAsync(fs, oldWrap, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)), old_flags); + const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len))); + await fs.promises.link(resolvedOldPath, resolvedNewPath); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i32', 'i32'], ['i32']); + function pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags) { + const read = (fs_rights_base & (WasiRights.FD_READ | + WasiRights.FD_READDIR)) !== BigInt(0); + const write = (fs_rights_base & (WasiRights.FD_DATASYNC | + WasiRights.FD_WRITE | + WasiRights.FD_ALLOCATE | + WasiRights.FD_FILESTAT_SET_SIZE)) !== BigInt(0); + let flags = write ? read ? 2 /* FileControlFlag.O_RDWR */ : 1 /* FileControlFlag.O_WRONLY */ : 0 /* FileControlFlag.O_RDONLY */; + let needed_base = WasiRights.PATH_OPEN; + let needed_inheriting = fs_rights_base | fs_rights_inheriting; + if ((o_flags & 1 /* WasiFileControlFlag.O_CREAT */) !== 0) { + flags |= 64 /* FileControlFlag.O_CREAT */; + needed_base |= WasiRights.PATH_CREATE_FILE; + } + if ((o_flags & 2 /* WasiFileControlFlag.O_DIRECTORY */) !== 0) { + flags |= 65536 /* FileControlFlag.O_DIRECTORY */; + } + if ((o_flags & 4 /* WasiFileControlFlag.O_EXCL */) !== 0) { + flags |= 128 /* FileControlFlag.O_EXCL */; + } + if ((o_flags & 8 /* WasiFileControlFlag.O_TRUNC */) !== 0) { + flags |= 512 /* FileControlFlag.O_TRUNC */; + needed_base |= WasiRights.PATH_FILESTAT_SET_SIZE; + } + if ((fs_flags & 1 /* WasiFdFlag.APPEND */) !== 0) { + flags |= 1024 /* FileControlFlag.O_APPEND */; + } + if ((fs_flags & 2 /* WasiFdFlag.DSYNC */) !== 0) { + // flags |= FileControlFlag.O_DSYNC; + needed_inheriting |= WasiRights.FD_DATASYNC; + } + if ((fs_flags & 4 /* WasiFdFlag.NONBLOCK */) !== 0) { + flags |= 2048 /* FileControlFlag.O_NONBLOCK */; + } + if ((fs_flags & 8 /* WasiFdFlag.RSYNC */) !== 0) { + flags |= 1052672 /* FileControlFlag.O_SYNC */; + needed_inheriting |= WasiRights.FD_SYNC; + } + if ((fs_flags & 16 /* WasiFdFlag.SYNC */) !== 0) { + flags |= 1052672 /* FileControlFlag.O_SYNC */; + needed_inheriting |= WasiRights.FD_SYNC; + } + if (write && (flags & (1024 /* FileControlFlag.O_APPEND */ | 512 /* FileControlFlag.O_TRUNC */)) === 0) { + needed_inheriting |= WasiRights.FD_SEEK; + } + return { flags, needed_base, needed_inheriting }; + } + defineImport('path_open', function path_open(dirfd, dirflags, path, path_len, o_flags, fs_rights_base, fs_rights_inheriting, fs_flags, fd) { + path = Number(path); + fd = Number(fd); + if (path === 0 || fd === 0) { + return 28 /* WasiErrno.EINVAL */; + } + path_len = Number(path_len); + fs_rights_base = BigInt(fs_rights_base); + fs_rights_inheriting = BigInt(fs_rights_inheriting); + const { flags: flagsRes, needed_base: neededBase, needed_inheriting: neededInheriting } = pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(dirfd, neededBase, neededInheriting); + const memory = getMemory(this); + const HEAPU8 = memory.HEAPU8; + const pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + const fs = getFs(this); + const resolved_path = resolvePathSync(fs, fileDescriptor, pathString, dirflags); + const r = fs.openSync(resolved_path, flagsRes, 0o666); + const filetype = wasi.fds.getFileTypeByFd(r); + if ((o_flags & 2 /* WasiFileControlFlag.O_DIRECTORY */) !== 0 && filetype !== 3 /* WasiFileType.DIRECTORY */) { + return 54 /* WasiErrno.ENOTDIR */; + } + const { base: max_base, inheriting: max_inheriting } = getRights(wasi.fds.stdio, r, flagsRes, filetype); + const wrap = wasi.fds.insert(r, resolved_path, resolved_path, filetype, fs_rights_base & max_base, fs_rights_inheriting & max_inheriting, 0); + const stat = fs.fstatSync(r, { bigint: true }); + if (stat.isFile()) { + wrap.size = stat.size; + if ((flagsRes & 1024 /* FileControlFlag.O_APPEND */) !== 0) { + wrap.pos = stat.size; + } + } + const view = memory.view; + view.setInt32(fd, wrap.id, true); + return 0 /* WasiErrno.ESUCCESS */; + }, async function path_open(dirfd, dirflags, path, path_len, o_flags, fs_rights_base, fs_rights_inheriting, fs_flags, fd) { + path = Number(path); + fd = Number(fd); + if (path === 0 || fd === 0) { + return 28 /* WasiErrno.EINVAL */; + } + path_len = Number(path_len); + fs_rights_base = BigInt(fs_rights_base); + fs_rights_inheriting = BigInt(fs_rights_inheriting); + const { flags: flagsRes, needed_base: neededBase, needed_inheriting: neededInheriting } = pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(dirfd, neededBase, neededInheriting); + const memory = getMemory(this); + const HEAPU8 = memory.HEAPU8; + const pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + const fs = getFs(this); + const resolved_path = await resolvePathAsync(fs, fileDescriptor, pathString, dirflags); + const r = await fs.promises.open(resolved_path, flagsRes, 0o666); + const filetype = await wasi.fds.getFileTypeByFd(r); + if ((o_flags & 2 /* WasiFileControlFlag.O_DIRECTORY */) !== 0 && filetype !== 3 /* WasiFileType.DIRECTORY */) { + return 54 /* WasiErrno.ENOTDIR */; + } + const { base: max_base, inheriting: max_inheriting } = getRights(wasi.fds.stdio, r.fd, flagsRes, filetype); + const wrap = wasi.fds.insert(r, resolved_path, resolved_path, filetype, fs_rights_base & max_base, fs_rights_inheriting & max_inheriting, 0); + const stat = await r.stat({ bigint: true }); + if (stat.isFile()) { + wrap.size = stat.size; + if ((flagsRes & 1024 /* FileControlFlag.O_APPEND */) !== 0) { + wrap.pos = stat.size; + } + } + const view = memory.view; + view.setInt32(fd, wrap.id, true); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i64', 'i64', 'i32', 'i32'], ['i32']); + defineImport('path_readlink', function path_readlink(fd, path, path_len, buf, buf_len, bufused) { + path = Number(path); + path_len = Number(path_len); + buf = Number(buf); + buf_len = Number(buf_len); + bufused = Number(bufused); + if (path === 0 || buf === 0 || bufused === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_READLINK, BigInt(0)); + let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + pathString = resolve(fileDescriptor.realPath, pathString); + const fs = getFs(this); + const link = fs.readlinkSync(pathString); + const linkData = encoder.encode(link); + const len = Math.min(linkData.length, buf_len); + if (len >= buf_len) + return 42 /* WasiErrno.ENOBUFS */; + HEAPU8.set(linkData.subarray(0, len), buf); + HEAPU8[buf + len] = 0; + view.setUint32(bufused, len, true); + return 0 /* WasiErrno.ESUCCESS */; + }, async function path_readlink(fd, path, path_len, buf, buf_len, bufused) { + path = Number(path); + path_len = Number(path_len); + buf = Number(buf); + buf_len = Number(buf_len); + bufused = Number(bufused); + if (path === 0 || buf === 0 || bufused === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8, view } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_READLINK, BigInt(0)); + let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + pathString = resolve(fileDescriptor.realPath, pathString); + const fs = getFs(this); + const link = await fs.promises.readlink(pathString); + const linkData = encoder.encode(link); + const len = Math.min(linkData.length, buf_len); + if (len >= buf_len) + return 42 /* WasiErrno.ENOBUFS */; + HEAPU8.set(linkData.subarray(0, len), buf); + HEAPU8[buf + len] = 0; + view.setUint32(bufused, len, true); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i32'], ['i32']); + defineImport('path_remove_directory', function path_remove_directory(fd, path, path_len) { + path = Number(path); + path_len = Number(path_len); + if (path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8 } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_REMOVE_DIRECTORY, BigInt(0)); + let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + pathString = resolve(fileDescriptor.realPath, pathString); + const fs = getFs(this); + fs.rmdirSync(pathString); + return 0 /* WasiErrno.ESUCCESS */; + }, async function path_remove_directory(fd, path, path_len) { + path = Number(path); + path_len = Number(path_len); + if (path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8 } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_REMOVE_DIRECTORY, BigInt(0)); + let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + pathString = resolve(fileDescriptor.realPath, pathString); + const fs = getFs(this); + await fs.promises.rmdir(pathString); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32'], ['i32']); + defineImport('path_rename', function path_rename(old_fd, old_path, old_path_len, new_fd, new_path, new_path_len) { + old_path = Number(old_path); + old_path_len = Number(old_path_len); + new_path = Number(new_path); + new_path_len = Number(new_path_len); + if (old_path === 0 || new_path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const wasi = _wasi.get(this); + let oldWrap; + let newWrap; + if (old_fd === new_fd) { + oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE | WasiRights.PATH_RENAME_TARGET, BigInt(0)); + } + else { + oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE, BigInt(0)); + newWrap = wasi.fds.get(new_fd, WasiRights.PATH_RENAME_TARGET, BigInt(0)); + } + const { HEAPU8 } = getMemory(this); + const resolvedOldPath = resolve(oldWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len))); + const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len))); + const fs = getFs(this); + fs.renameSync(resolvedOldPath, resolvedNewPath); + return 0 /* WasiErrno.ESUCCESS */; + }, async function path_rename(old_fd, old_path, old_path_len, new_fd, new_path, new_path_len) { + old_path = Number(old_path); + old_path_len = Number(old_path_len); + new_path = Number(new_path); + new_path_len = Number(new_path_len); + if (old_path === 0 || new_path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const wasi = _wasi.get(this); + let oldWrap; + let newWrap; + if (old_fd === new_fd) { + oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE | WasiRights.PATH_RENAME_TARGET, BigInt(0)); + } + else { + oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE, BigInt(0)); + newWrap = wasi.fds.get(new_fd, WasiRights.PATH_RENAME_TARGET, BigInt(0)); + } + const { HEAPU8 } = getMemory(this); + const resolvedOldPath = resolve(oldWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len))); + const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len))); + const fs = getFs(this); + await fs.promises.rename(resolvedOldPath, resolvedNewPath); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i32'], ['i32']); + defineImport('path_symlink', function path_symlink(old_path, old_path_len, fd, new_path, new_path_len) { + old_path = Number(old_path); + old_path_len = Number(old_path_len); + new_path = Number(new_path); + new_path_len = Number(new_path_len); + if (old_path === 0 || new_path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8 } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_SYMLINK, BigInt(0)); + const oldPath = decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)); + let newPath = decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len)); + newPath = resolve(fileDescriptor.realPath, newPath); + const fs = getFs(this); + fs.symlinkSync(oldPath, newPath); + return 0 /* WasiErrno.ESUCCESS */; + }, async function path_symlink(old_path, old_path_len, fd, new_path, new_path_len) { + old_path = Number(old_path); + old_path_len = Number(old_path_len); + new_path = Number(new_path); + new_path_len = Number(new_path_len); + if (old_path === 0 || new_path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8 } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_SYMLINK, BigInt(0)); + const oldPath = decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)); + let newPath = decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len)); + newPath = resolve(fileDescriptor.realPath, newPath); + const fs = getFs(this); + await fs.promises.symlink(oldPath, newPath); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32', 'i32', 'i32'], ['i32']); + defineImport('path_unlink_file', function path_unlink_file(fd, path, path_len) { + path = Number(path); + path_len = Number(path_len); + if (path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8 } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_UNLINK_FILE, BigInt(0)); + let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + pathString = resolve(fileDescriptor.realPath, pathString); + const fs = getFs(this); + fs.unlinkSync(pathString); + return 0 /* WasiErrno.ESUCCESS */; + }, async function path_unlink_file(fd, path, path_len) { + path = Number(path); + path_len = Number(path_len); + if (path === 0) { + return 28 /* WasiErrno.EINVAL */; + } + const { HEAPU8 } = getMemory(this); + const wasi = _wasi.get(this); + const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_UNLINK_FILE, BigInt(0)); + let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)); + pathString = resolve(fileDescriptor.realPath, pathString); + const fs = getFs(this); + await fs.promises.unlink(pathString); + return 0 /* WasiErrno.ESUCCESS */; + }, ['i32', 'i32', 'i32'], ['i32']); + this._setMemory = function setMemory(m) { + if (!(m instanceof _WebAssembly.Memory)) { + throw new TypeError('"instance.exports.memory" property must be a WebAssembly.Memory'); + } + _memory.set(_this, extendMemory(m)); + }; + } + static createSync(args, env, preopens, stdio, fs, print, printErr) { + const fds = new SyncTable({ + size: 3, + in: stdio[0], + out: stdio[1], + err: stdio[2], + fs, + print, + printErr + }); + const _this = new WASI$1(args, env, fds, false, fs); + if (preopens.length > 0) { + for (let i = 0; i < preopens.length; ++i) { + const realPath = fs.realpathSync(preopens[i].realPath, 'utf8'); + const fd = fs.openSync(realPath, 'r', 0o666); + fds.insertPreopen(fd, preopens[i].mappedPath, realPath); + } + } + return _this; + } + static async createAsync(args, env, preopens, stdio, fs, print, printErr, asyncify) { + const fds = new AsyncTable({ + size: 3, + in: stdio[0], + out: stdio[1], + err: stdio[2], + print, + printErr + }); + const _this = new WASI$1(args, env, fds, true, fs, asyncify); + if (preopens.length > 0) { + for (let i = 0; i < preopens.length; ++i) { + const entry = preopens[i]; + const realPath = await fs.promises.realpath(entry.realPath); + const fd = await fs.promises.open(realPath, 'r', 0o666); + await fds.insertPreopen(fd, entry.mappedPath, realPath); + } + } + return _this; + } +} + +// eslint-disable-next-line spaced-comment +const kEmptyObject = /*#__PURE__*/ Object.freeze(/*#__PURE__*/ Object.create(null)); +const kExitCode = Symbol('kExitCode'); +const kSetMemory = Symbol('kSetMemory'); +const kStarted = Symbol('kStarted'); +const kInstance = Symbol('kInstance'); +const kBindingName = Symbol('kBindingName'); +function setupInstance(self, instance) { + validateObject(instance, 'instance'); + validateObject(instance.exports, 'instance.exports'); + self[kInstance] = instance; + self[kSetMemory](instance.exports.memory); +} +function validateOptions(options) { + var _a; + validateObject(options, 'options'); + let _WASI; + if (options.version !== undefined) { + validateString(options.version, 'options.version'); + switch (options.version) { + case 'unstable': + _WASI = WASI$1; + this[kBindingName] = 'wasi_unstable'; + break; + case 'preview1': + _WASI = WASI$1; + this[kBindingName] = 'wasi_snapshot_preview1'; + break; + default: + throw new TypeError(`unsupported WASI version "${options.version}"`); + } + } + else { + _WASI = WASI$1; + this[kBindingName] = 'wasi_snapshot_preview1'; + } + if (options.args !== undefined) { + validateArray(options.args, 'options.args'); + } + const args = ((_a = options.args) !== null && _a !== void 0 ? _a : []).map(String); + const env = []; + if (options.env !== undefined) { + validateObject(options.env, 'options.env'); + Object.entries(options.env).forEach(({ 0: key, 1: value }) => { + if (value !== undefined) { + env.push(`${key}=${value}`); + } + }); + } + const preopens = []; + if (options.preopens !== undefined) { + validateObject(options.preopens, 'options.preopens'); + Object.entries(options.preopens).forEach(({ 0: key, 1: value }) => preopens.push({ mappedPath: String(key), realPath: String(value) })); + } + if (preopens.length > 0) { + if (options.fs === undefined) { + throw new Error('filesystem is disabled, can not preopen directory'); + } + try { + validateObject(options.fs, 'options.fs'); + } + catch (_) { + throw new TypeError('Node.js fs like implementation is not provided'); + } + } + // if (options.filesystem !== undefined) { + // validateObject(options.filesystem, 'options.filesystem') + // validateString(options.filesystem.type, 'options.filesystem.type') + // if (options.filesystem.type !== 'memfs' && options.filesystem.type !== 'file-system-access-api') { + // throw new Error(`Filesystem type ${(options.filesystem as any).type as string} is not supported, only "memfs" and "file-system-access-api" is supported currently`) + // } + // try { + // validateObject(options.filesystem.fs, 'options.filesystem.fs') + // } catch (_) { + // throw new Error('Node.js fs like implementation is not provided') + // } + // } + if (options.print !== undefined) + validateFunction(options.print, 'options.print'); + if (options.printErr !== undefined) + validateFunction(options.printErr, 'options.printErr'); + if (options.returnOnExit !== undefined) { + validateBoolean(options.returnOnExit, 'options.returnOnExit'); + } + // const { stdin = 0, stdout = 1, stderr = 2 } = options + // validateInt32(stdin, 'options.stdin', 0) + // validateInt32(stdout, 'options.stdout', 0) + // validateInt32(stderr, 'options.stderr', 0) + // const stdio = [stdin, stdout, stderr] as const + const stdio = [0, 1, 2]; + return { + args, + env, + preopens, + stdio, + _WASI + }; +} +function initWASI(setMemory, wrap) { + this[kSetMemory] = setMemory; + this.wasiImport = wrap; + this[kStarted] = false; + this[kExitCode] = 0; + this[kInstance] = undefined; +} +/** @public */ +class WASI { + constructor(options = kEmptyObject) { + const { args, env, preopens, stdio, _WASI } = validateOptions.call(this, options); + const wrap = _WASI.createSync(args, env, preopens, stdio, options.fs, options.print, options.printErr); + const setMemory = wrap._setMemory; + delete wrap._setMemory; + initWASI.call(this, setMemory, wrap); + if (options.returnOnExit) { + wrap.proc_exit = wasiReturnOnProcExit.bind(this); + } + } + // Must not export _initialize, must export _start + start(instance) { + if (this[kStarted]) { + throw new Error('WASI instance has already started'); + } + this[kStarted] = true; + setupInstance(this, instance); + const { _start, _initialize } = this[kInstance].exports; + validateFunction(_start, 'instance.exports._start'); + validateUndefined(_initialize, 'instance.exports._initialize'); + let ret; + try { + ret = _start(); + } + catch (err) { + if (err !== kExitCode) { + throw err; + } + } + if (ret instanceof Promise) { + return ret.then(() => this[kExitCode], (err) => { + if (err !== kExitCode) { + throw err; + } + return this[kExitCode]; + }); + } + return this[kExitCode]; + } + // Must not export _start, may optionally export _initialize + initialize(instance) { + if (this[kStarted]) { + throw new Error('WASI instance has already started'); + } + this[kStarted] = true; + setupInstance(this, instance); + const { _start, _initialize } = this[kInstance].exports; + validateUndefined(_start, 'instance.exports._start'); + if (_initialize !== undefined) { + validateFunction(_initialize, 'instance.exports._initialize'); + return _initialize(); + } + } + getImportObject() { + return { [this[kBindingName]]: this.wasiImport }; + } +} +function wasiReturnOnProcExit(rval) { + this[kExitCode] = rval; + // eslint-disable-next-line @typescript-eslint/no-throw-literal + throw kExitCode; +} + +// @ts-check + +/** + * @param {unknown} value + */ +const getType = (value) => { + if (value === undefined) return 0 + if (value === null) return 1 + const t = typeof value; + if (t === 'boolean') return 2 + if (t === 'number') return 3 + if (t === 'string') return 4 + if (t === 'object') return 6 + if (t === 'bigint') return 9 + return -1 +}; + +/** + * @param {import('memfs').IFs} memfs + * @param {any} value + * @param {ReturnType} type + * @returns {Uint8Array} + */ +const encodeValue = (memfs, value, type) => { + switch (type) { + case 0: + case 1: + return new Uint8Array(0) + case 2: { + const view = new Int32Array(1); + view[0] = value ? 1 : 0; + return new Uint8Array(view.buffer) + } + case 3: { + const view = new Float64Array(1); + view[0] = value; + return new Uint8Array(view.buffer) + } + case 4: { + const view = new TextEncoder().encode(value); + return view + } + case 6: { + const [entry] = Object.entries(memfs).filter(([_, v]) => v === value.constructor)[0] ?? []; + if (entry) { + Object.defineProperty(value, '__constructor__', { + configurable: true, + writable: true, + enumerable: true, + value: entry + }); + } + + const json = JSON.stringify(value, (_, value) => { + if (typeof value === 'bigint') { + return `BigInt(${String(value)})` + } + return value + }); + const view = new TextEncoder().encode(json); + return view + } + case 9: { + const view = new BigInt64Array(1); + view[0] = value; + return new Uint8Array(view.buffer) + } + case -1: + default: + throw new Error('unsupported data') + } +}; + +/** + * @param {import('memfs').IFs} fs + * @returns {(e: { data: { __fs__: { sab: Int32Array, type: keyof import('memfs').IFs, payload: any[] } } }) => void} + */ +var createOnMessage = (fs) => function onMessage(e) { + if (e.data.__fs__) { + /** + * 0..4 status(int32_t): 21(waiting) 0(success) 1(error) + * 5..8 type(napi_valuetype): 0(undefined) 1(null) 2(boolean) 3(number) 4(string) 6(jsonstring) 9(bigint) -1(unsupported) + * 9..16 payload_size(uint32_t) <= 1024 + * 16..16 + payload_size payload_content + */ + const { sab, type, payload } = e.data.__fs__; + const fn = fs[type]; + const args = payload ? payload.map((value) => { + if (value instanceof Uint8Array) { + // buffer polyfill bug + // @ts-expect-error + value._isBuffer = true; + } + return value + }) : payload; + try { + const ret = fn.apply(fs, args); + const t = getType(ret); + const v = encodeValue(fs, ret, t); + Atomics.store(sab, 0, 0); + Atomics.store(sab, 1, t); + Atomics.store(sab, 2, v.length); + new Uint8Array(sab.buffer).set(v, 16); + + } catch (/** @type {any} */ err) { + Atomics.store(sab, 0, 1); + Atomics.store(sab, 1, 6); + const payloadContent = new TextEncoder().encode(JSON.stringify({ + ...err, + message: err.message, + stack: err.stack + })); + Atomics.store(sab, 2, payloadContent.length); + new Uint8Array(sab.buffer).set(payloadContent, 16); + } finally { + Atomics.notify(sab, 0); + } + } +}; + +/** + * @param {import('memfs').IFs} memfs + */ +var createFsProxy = (memfs) => new Proxy({}, { + get (_target, p, _receiver) { + /** + * @param {any[]} args + */ + return function (...args) { + const sab = new SharedArrayBuffer(16 + 1024); + const i32arr = new Int32Array(sab); + Atomics.store(i32arr, 0, 21); + + // @ts-expect-error + postMessage({ + __fs__: { + sab: i32arr, + type: p, + payload: args + } + }); + + Atomics.wait(i32arr, 0, 21); + + const status = Atomics.load(i32arr, 0); + const type = Atomics.load(i32arr, 1); + const size = Atomics.load(i32arr, 2); + const content = new Uint8Array(sab, 16, size); + if (status === 1) { + const errobj = JSON.parse(new TextDecoder().decode(content.slice())); + const err = new Error(errobj.message); + Object.defineProperty(err, 'stack', { + configurable: true, + enumerable: false, + writable: true, + value: errobj.stack + }); + for (const [k, v] of Object.entries(errobj)) { + if (k === 'message' || k === 'stack') continue + // @ts-expect-error + err[k] = v; + } + throw err + } + if (type === 0) return undefined + if (type === 1) return null + if (type === 2) return Boolean(content[0]) + if (type === 3) return new Float64Array(sab, 16, 1)[0] + if (type === 4) return new TextDecoder().decode(content.slice()) + if (type === 6) { + const obj = JSON.parse(new TextDecoder().decode(content.slice()), (_key, value) => { + if (typeof value === 'string') { + const matched = value.match(/^BigInt\((-?\d+)\)$/); + if (matched && matched[1]) { + return BigInt(matched[1]) + } + } + return value + }); + if (obj.__constructor__) { + const ctor = obj.__constructor__; + delete obj.__constructor__; + // @ts-expect-error + Object.setPrototypeOf(obj, memfs[ctor].prototype); + } + return obj + } + if (type === 9) return new BigInt64Array(sab, 16, 1)[0] + throw new Error('unsupported data') + } + } +}); + +export { MessageHandler, WASI, createFsProxy, createOnMessage, getDefaultContext, instantiateNapiModule, instantiateNapiModuleSync }; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"runtime.js","sources":["../../node_modules/@emnapi/core/dist/emnapi-core.esm-bundler.js","../../node_modules/tslib/tslib.es6.mjs","../../node_modules/@emnapi/runtime/dist/emnapi.esm-bundler.js","../../node_modules/@tybys/wasm-util/dist/wasm-util.esm-bundler.js","../fs-proxy.cjs"],"sourcesContent":["/* eslint-disable no-undef */\nvar _WebAssembly = typeof WebAssembly !== 'undefined'\n    ? WebAssembly\n    : typeof WXWebAssembly !== 'undefined'\n        ? WXWebAssembly\n        : undefined;\nfunction validateImports(imports) {\n    if (imports && typeof imports !== 'object') {\n        throw new TypeError('imports must be an object or undefined');\n    }\n    return true;\n}\nfunction load(wasmInput, imports) {\n    if (!wasmInput)\n        throw new TypeError('Invalid wasm source');\n    validateImports(imports);\n    imports = imports !== null && imports !== void 0 ? imports : {};\n    // Promise<string | URL | Response | BufferSource | WebAssembly.Module>\n    try {\n        var then = typeof wasmInput === 'object' && wasmInput !== null && 'then' in wasmInput ? wasmInput.then : undefined;\n        if (typeof then === 'function') {\n            return then.call(wasmInput, function (input) { return load(input, imports); });\n        }\n    }\n    catch (_) { }\n    // BufferSource\n    if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) {\n        return _WebAssembly.instantiate(wasmInput, imports);\n    }\n    // WebAssembly.Module\n    if (wasmInput instanceof _WebAssembly.Module) {\n        return _WebAssembly.instantiate(wasmInput, imports).then(function (instance) {\n            return { instance: instance, module: wasmInput };\n        });\n    }\n    // Response\n    if (typeof Response !== 'undefined' && wasmInput instanceof Response) {\n        return wasmInput.arrayBuffer().then(function (buffer) {\n            return _WebAssembly.instantiate(buffer, imports);\n        });\n    }\n    // string | URL\n    var inputIsString = typeof wasmInput === 'string';\n    if (inputIsString || (typeof URL !== 'undefined' && wasmInput instanceof URL)) {\n        if (inputIsString && typeof wx !== 'undefined' && typeof __wxConfig !== 'undefined') {\n            return _WebAssembly.instantiate(wasmInput, imports);\n        }\n        if (typeof fetch !== 'function') {\n            throw new TypeError('wasm source can not be a string or URL in this environment');\n        }\n        if (typeof _WebAssembly.instantiateStreaming === 'function') {\n            try {\n                return _WebAssembly.instantiateStreaming(fetch(wasmInput), imports).catch(function () {\n                    return load(fetch(wasmInput), imports);\n                });\n            }\n            catch (_) {\n                return load(fetch(wasmInput), imports);\n            }\n        }\n        else {\n            return load(fetch(wasmInput), imports);\n        }\n    }\n    throw new TypeError('Invalid wasm source');\n}\nfunction loadSync(wasmInput, imports) {\n    if (!wasmInput)\n        throw new TypeError('Invalid wasm source');\n    validateImports(imports);\n    imports = imports !== null && imports !== void 0 ? imports : {};\n    var module;\n    if ((wasmInput instanceof ArrayBuffer) || ArrayBuffer.isView(wasmInput)) {\n        module = new _WebAssembly.Module(wasmInput);\n    }\n    else if (wasmInput instanceof WebAssembly.Module) {\n        module = wasmInput;\n    }\n    else {\n        throw new TypeError('Invalid wasm source');\n    }\n    var instance = new _WebAssembly.Instance(module, imports);\n    var source = { instance: instance, module: module };\n    return source;\n}\n\nfunction createNapiModule(options) {\n    var napiModule = (function () {\n        var ENVIRONMENT_IS_NODE = typeof process === 'object' && process !== null && typeof process.versions === 'object' && process.versions !== null && typeof process.versions.node === 'string';\n        var ENVIRONMENT_IS_PTHREAD = Boolean(options.childThread);\n        var reuseWorker = Boolean(options.reuseWorker);\n        var wasmInstance;\n        var wasmModule;\n        var wasmMemory;\n        var wasmTable;\n        var _malloc;\n        var _free;\n        function abort(msg) {\n            if (typeof _WebAssembly.RuntimeError === 'function') {\n                throw new _WebAssembly.RuntimeError(msg);\n            }\n            throw Error(msg);\n        }\n        var napiModule = {\n            imports: {\n                env: {},\n                napi: {},\n                emnapi: {}\n            },\n            exports: {},\n            emnapi: {},\n            loaded: false,\n            filename: '',\n            childThread: Boolean(options.childThread),\n            spawnThread: undefined,\n            startThread: undefined,\n            initWorker: undefined,\n            executeAsyncWork: undefined,\n            init: function (options) {\n                if (napiModule.loaded)\n                    return napiModule.exports;\n                if (!options)\n                    throw new TypeError('Invalid napi init options');\n                var instance = options.instance;\n                if (!(instance === null || instance === void 0 ? void 0 : instance.exports))\n                    throw new TypeError('Invalid wasm instance');\n                wasmInstance = instance;\n                var exports = instance.exports;\n                var module = options.module;\n                var memory = options.memory || exports.memory;\n                var table = options.table || exports.__indirect_function_table;\n                if (!(module instanceof _WebAssembly.Module))\n                    throw new TypeError('Invalid wasm module');\n                if (!(memory instanceof _WebAssembly.Memory))\n                    throw new TypeError('Invalid wasm memory');\n                if (!(table instanceof _WebAssembly.Table))\n                    throw new TypeError('Invalid wasm table');\n                wasmModule = module;\n                wasmMemory = memory;\n                wasmTable = table;\n                if (typeof exports.malloc !== 'function')\n                    throw new TypeError('malloc is not exported');\n                if (typeof exports.free !== 'function')\n                    throw new TypeError('free is not exported');\n                _malloc = exports.malloc;\n                _free = exports.free;\n                if (!napiModule.childThread) {\n                    // main thread only\n                    var moduleApiVersion = 8 /* Version.NODE_API_DEFAULT_MODULE_API_VERSION */;\n                    var node_api_module_get_api_version_v1 = instance.exports.node_api_module_get_api_version_v1;\n                    if (typeof node_api_module_get_api_version_v1 === 'function') {\n                        moduleApiVersion = node_api_module_get_api_version_v1();\n                    }\n                    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n                    var envObject = napiModule.envObject || (napiModule.envObject = emnapiCtx.createEnv(napiModule.filename, moduleApiVersion, function (cb) { return (wasmTable.get(cb)); }, function (cb) { return (wasmTable.get(cb)); }, abort, emnapiNodeBinding));\n                    var scope_1 = emnapiCtx.openScope(envObject);\n                    try {\n                        envObject.callIntoModule(function (_envObject) {\n                            var exports = napiModule.exports;\n                            var exportsHandle = scope_1.add(exports);\n                            var napi_register_wasm_v1 = instance.exports.napi_register_wasm_v1;\n                            var napiValue = napi_register_wasm_v1(_envObject.id, exportsHandle.id);\n                            napiModule.exports = (!napiValue) ? exports : emnapiCtx.handleStore.get(napiValue).value;\n                        });\n                    }\n                    finally {\n                        emnapiCtx.closeScope(envObject, scope_1);\n                    }\n                    napiModule.loaded = true;\n                    delete napiModule.envObject;\n                    return napiModule.exports;\n                }\n            }\n        };\n        var emnapiCtx;\n        var emnapiNodeBinding;\n        var onCreateWorker;\n        var err;\n        if (!ENVIRONMENT_IS_PTHREAD) {\n            var context = options.context;\n            if (typeof context !== 'object' || context === null) {\n                throw new TypeError(\"Invalid `options.context`. Use `import { getDefaultContext } from '@emnapi/runtime'`\");\n            }\n            emnapiCtx = context;\n        }\n        else {\n            emnapiCtx = options === null || options === void 0 ? void 0 : options.context;\n            var postMsg = typeof options.postMessage === 'function'\n                ? options.postMessage\n                : typeof postMessage === 'function'\n                    ? postMessage\n                    : undefined;\n            if (typeof postMsg !== 'function') {\n                throw new TypeError('No postMessage found');\n            }\n            napiModule.postMessage = postMsg;\n        }\n        if (typeof options.filename === 'string') {\n            napiModule.filename = options.filename;\n        }\n        if (typeof options.onCreateWorker === 'function') {\n            onCreateWorker = options.onCreateWorker;\n        }\n        if (typeof options.print === 'function') {\n            options.print;\n        }\n        else {\n            console.log.bind(console);\n        }\n        if (typeof options.printErr === 'function') {\n            err = options.printErr;\n        }\n        else {\n            err = console.warn.bind(console);\n        }\n        if ('nodeBinding' in options) {\n            var nodeBinding = options.nodeBinding;\n            if (typeof nodeBinding !== 'object' || nodeBinding === null) {\n                throw new TypeError('Invalid `options.nodeBinding`. Use @emnapi/node-binding package');\n            }\n            emnapiNodeBinding = nodeBinding;\n        }\n        var emnapiAsyncWorkPoolSize = 0;\n        if ('asyncWorkPoolSize' in options) {\n            if (typeof options.asyncWorkPoolSize !== 'number') {\n                throw new TypeError('options.asyncWorkPoolSize must be a integer');\n            }\n            emnapiAsyncWorkPoolSize = options.asyncWorkPoolSize >> 0;\n            if (emnapiAsyncWorkPoolSize > 1024) {\n                emnapiAsyncWorkPoolSize = 1024;\n            }\n            else if (emnapiAsyncWorkPoolSize < -1024) {\n                emnapiAsyncWorkPoolSize = -1024;\n            }\n        }\n        var singleThreadAsyncWork = ENVIRONMENT_IS_PTHREAD ? false : (emnapiAsyncWorkPoolSize <= 0);\n        function _emnapi_async_work_pool_size() {\n            return Math.abs(emnapiAsyncWorkPoolSize);\n        }\n        napiModule.imports.env._emnapi_async_work_pool_size = _emnapi_async_work_pool_size;\n        // ------------------------------ pthread -------------------------------\n        function emnapiAddSendListener(worker) {\n            if (!worker)\n                return false;\n            if (worker._emnapiSendListener)\n                return true;\n            var handler = function (e) {\n                var data = ENVIRONMENT_IS_NODE ? e : e.data;\n                var __emnapi__ = data.__emnapi__;\n                if (__emnapi__ && __emnapi__.type === 'async-send') {\n                    if (ENVIRONMENT_IS_PTHREAD) {\n                        var postMessage_1 = napiModule.postMessage;\n                        postMessage_1({ __emnapi__: __emnapi__ });\n                    }\n                    else {\n                        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                        var callback = __emnapi__.payload.callback;\n                        (wasmTable.get(callback))(__emnapi__.payload.data);\n                    }\n                }\n            };\n            var dispose = function () {\n                if (ENVIRONMENT_IS_NODE) {\n                    worker.off('message', handler);\n                }\n                else {\n                    worker.removeEventListener('message', handler, false);\n                }\n                delete worker._emnapiSendListener;\n            };\n            worker._emnapiSendListener = { handler: handler, dispose: dispose };\n            if (ENVIRONMENT_IS_NODE) {\n                worker.on('message', handler);\n            }\n            else {\n                worker.addEventListener('message', handler, false);\n            }\n            return true;\n        }\n        napiModule.emnapi.addSendListener = emnapiAddSendListener;\n        function terminateWorker(worker) {\n            var tid = worker.__emnapi_tid;\n            worker.terminate();\n            worker.onmessage = function (e) {\n                if (e.data.__emnapi__) {\n                    err('received \"' + e.data.__emnapi__.type + '\" command from terminated worker: ' + tid);\n                }\n            };\n        }\n        function spawnThread(startArg, errorOrTid) {\n            var isNewABI = errorOrTid !== undefined;\n            if (!isNewABI) {\n                errorOrTid = _malloc(8);\n                if (!errorOrTid) {\n                    return -48; /* ENOMEM */\n                }\n            }\n            var struct = new Int32Array(wasmMemory.buffer, errorOrTid, 2);\n            Atomics.store(struct, 0, 0);\n            Atomics.store(struct, 1, 0);\n            if (ENVIRONMENT_IS_PTHREAD) {\n                var postMessage_2 = napiModule.postMessage;\n                postMessage_2({\n                    __emnapi__: {\n                        type: 'spawn-thread',\n                        payload: {\n                            startArg: startArg,\n                            errorOrTid: errorOrTid\n                        }\n                    }\n                });\n                Atomics.wait(struct, 1, 0);\n                var isError = Atomics.load(struct, 0);\n                var result = Atomics.load(struct, 1);\n                if (isNewABI) {\n                    return isError;\n                }\n                _free(errorOrTid);\n                return isError ? -result : result;\n            }\n            var worker;\n            try {\n                worker = PThread.getNewWorker();\n                if (!worker) {\n                    throw new Error('failed to get new worker');\n                }\n            }\n            catch (e) {\n                var EAGAIN = 6;\n                Atomics.store(struct, 0, 1);\n                Atomics.store(struct, 1, EAGAIN);\n                Atomics.notify(struct, 1);\n                err(e.message);\n                if (isNewABI) {\n                    return 1;\n                }\n                _free(errorOrTid);\n                return -EAGAIN;\n            }\n            var tid = PThread.nextWorkerID + 43;\n            Atomics.store(struct, 0, 0);\n            Atomics.store(struct, 1, tid);\n            Atomics.notify(struct, 1);\n            var WASI_THREADS_MAX_TID = 0x1FFFFFFF;\n            PThread.nextWorkerID = (PThread.nextWorkerID + 1) % (WASI_THREADS_MAX_TID - 42);\n            PThread.pthreads[tid] = worker;\n            worker.__emnapi_tid = tid;\n            PThread.runningWorkers.push(worker);\n            if (ENVIRONMENT_IS_NODE) {\n                worker.ref();\n            }\n            worker.postMessage({\n                __emnapi__: {\n                    type: 'start',\n                    payload: {\n                        tid: tid,\n                        arg: startArg\n                    }\n                }\n            });\n            if (isNewABI) {\n                return 0;\n            }\n            _free(errorOrTid);\n            return tid;\n        }\n        function startThread(tid, startArg) {\n            if (napiModule.childThread) {\n                if (typeof wasmInstance.exports.wasi_thread_start !== 'function') {\n                    throw new TypeError('wasi_thread_start is not exported');\n                }\n                var postMessage_3 = napiModule.postMessage;\n                wasmInstance.exports.wasi_thread_start(tid, startArg);\n                postMessage_3({\n                    __emnapi__: {\n                        type: 'cleanup-thread',\n                        payload: {\n                            tid: tid\n                        }\n                    }\n                });\n            }\n            else {\n                throw new Error('startThread is only available in child threads');\n            }\n        }\n        napiModule.spawnThread = spawnThread;\n        napiModule.startThread = startThread;\n        var PThread = {\n            unusedWorkers: [],\n            runningWorkers: [],\n            pthreads: Object.create(null),\n            nextWorkerID: 0,\n            init: function () { },\n            returnWorkerToPool: function (worker) {\n                var tid = worker.__emnapi_tid;\n                delete PThread.pthreads[tid];\n                PThread.unusedWorkers.push(worker);\n                PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1);\n                delete worker.__emnapi_tid;\n                if (ENVIRONMENT_IS_NODE) {\n                    worker.unref();\n                }\n            },\n            loadWasmModuleToWorker: function (worker) {\n                if (worker.whenLoaded)\n                    return worker.whenLoaded;\n                worker.whenLoaded = new Promise(function (resolve, reject) {\n                    worker.onmessage = function (e) {\n                        if (e.data.__emnapi__) {\n                            var type = e.data.__emnapi__.type;\n                            var payload = e.data.__emnapi__.payload;\n                            if (type === 'loaded') {\n                                worker.loaded = true;\n                                if (ENVIRONMENT_IS_NODE && !worker.__emnapi_tid) {\n                                    worker.unref();\n                                }\n                                resolve(worker);\n                                // if (payload.err) {\n                                //   err('failed to load in child thread: ' + (payload.err.message || payload.err))\n                                // }\n                            }\n                            else if (type === 'spawn-thread') {\n                                spawnThread(payload.startArg, payload.errorOrTid);\n                            }\n                            else if (type === 'cleanup-thread') {\n                                if (reuseWorker) {\n                                    PThread.returnWorkerToPool(worker);\n                                }\n                                else {\n                                    delete PThread.pthreads[payload.tid];\n                                    PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1);\n                                    terminateWorker(worker);\n                                    delete worker.__emnapi_tid;\n                                }\n                            }\n                        }\n                    };\n                    worker.onerror = function (e) {\n                        var message = 'worker sent an error!';\n                        // if (worker.pthread_ptr) {\n                        //   message = 'Pthread ' + ptrToString(worker.pthread_ptr) + ' sent an error!'\n                        // }\n                        err(message + ' ' + e.message);\n                        reject(e);\n                        throw e;\n                    };\n                    if (ENVIRONMENT_IS_NODE) {\n                        worker.on('message', function (data) {\n                            worker.onmessage({\n                                data: data\n                            });\n                        });\n                        worker.on('error', function (e) {\n                            worker.onerror(e);\n                        });\n                        worker.on('detachedExit', function () { });\n                    }\n                    // napiModule.emnapi.addSendListener(worker)\n                    emnapiAddSendListener(worker);\n                    // if (typeof emnapiTSFN !== 'undefined') {\n                    //   emnapiTSFN.addListener(worker)\n                    // }\n                    try {\n                        worker.postMessage({\n                            __emnapi__: {\n                                type: 'load',\n                                payload: {\n                                    wasmModule: wasmModule,\n                                    wasmMemory: wasmMemory\n                                }\n                            }\n                        });\n                    }\n                    catch (err) {\n                        if (typeof SharedArrayBuffer === 'undefined' || !(wasmMemory.buffer instanceof SharedArrayBuffer)) {\n                            throw new Error('Multithread features require shared wasm memory. ' +\n                                'Try to compile with `-matomics -mbulk-memory` and use `--import-memory --shared-memory` during linking');\n                        }\n                        throw err;\n                    }\n                });\n                return worker.whenLoaded;\n            },\n            allocateUnusedWorker: function () {\n                if (typeof onCreateWorker !== 'function') {\n                    throw new TypeError('`options.onCreateWorker` is not provided');\n                }\n                var worker = onCreateWorker({ type: 'thread' });\n                PThread.unusedWorkers.push(worker);\n                return worker;\n            },\n            getNewWorker: function () {\n                if (reuseWorker) {\n                    if (PThread.unusedWorkers.length === 0) {\n                        var worker_1 = PThread.allocateUnusedWorker();\n                        PThread.loadWasmModuleToWorker(worker_1);\n                    }\n                    return PThread.unusedWorkers.pop();\n                }\n                var worker = PThread.allocateUnusedWorker();\n                PThread.loadWasmModuleToWorker(worker);\n                return worker;\n            }\n        };\n        /**\n         * @__sig ipiip\n         */\n        function napi_set_last_error(env, error_code, engine_error_code, engine_reserved) {\n            var envObject = emnapiCtx.envStore.get(env);\n            return envObject.setLastError(error_code, engine_error_code, engine_reserved);\n        }\n        /**\n         * @__sig ip\n         */\n        function napi_clear_last_error(env) {\n            var envObject = emnapiCtx.envStore.get(env);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig vppp\n         */\n        function _emnapi_get_node_version(major, minor, patch) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var versions = (typeof process === 'object' && process !== null &&\n                typeof process.versions === 'object' && process.versions !== null &&\n                typeof process.versions.node === 'string')\n                ? process.versions.node.split('.').map(function (n) { return Number(n); })\n                : [0, 0, 0];\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setUint32(major, versions[0], true);\n            HEAP_DATA_VIEW.setUint32(minor, versions[1], true);\n            HEAP_DATA_VIEW.setUint32(patch, versions[2], true);\n        }\n        /**\n         * @__sig v\n         * @__deps $runtimeKeepalivePush\n         */\n        function _emnapi_runtime_keepalive_push() {\n        }\n        /**\n         * @__sig v\n         * @__deps $runtimeKeepalivePop\n         */\n        function _emnapi_runtime_keepalive_pop() {\n        }\n        /**\n         * @__sig vpp\n         */\n        function _emnapi_set_immediate(callback, data) {\n            emnapiCtx.feature.setImmediate(function () {\n                (wasmTable.get(callback))(data);\n            });\n        }\n        /**\n         * @__sig vpp\n         */\n        function _emnapi_next_tick(callback, data) {\n            // eslint-disable-next-line @typescript-eslint/no-floating-promises\n            Promise.resolve().then(function () {\n                (wasmTable.get(callback))(data);\n            });\n        }\n        /**\n         * @__sig vipppi\n         */\n        function _emnapi_callback_into_module(forceUncaught, env, callback, data, close_scope_if_throw) {\n            var envObject = emnapiCtx.envStore.get(env);\n            var scope = emnapiCtx.openScope(envObject);\n            try {\n                envObject.callbackIntoModule(Boolean(forceUncaught), function () {\n                    (wasmTable.get(callback))(env, data);\n                });\n            }\n            catch (err) {\n                emnapiCtx.closeScope(envObject, scope);\n                if (close_scope_if_throw) {\n                    emnapiCtx.closeScope(envObject);\n                }\n                throw err;\n            }\n            emnapiCtx.closeScope(envObject, scope);\n        }\n        /**\n         * @__sig vipppp\n         */\n        function _emnapi_call_finalizer(forceUncaught, env, callback, data, hint) {\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.callFinalizerInternal(forceUncaught, callback, data, hint);\n        }\n        /**\n         * @__sig v\n         */\n        function _emnapi_ctx_increase_waiting_request_counter() {\n            emnapiCtx.increaseWaitingRequestCounter();\n        }\n        /**\n         * @__sig v\n         */\n        function _emnapi_ctx_decrease_waiting_request_counter() {\n            emnapiCtx.decreaseWaitingRequestCounter();\n        }\n        function $emnapiSetValueI64(result, numberValue) {\n            var tempDouble;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var tempI64 = [\n                numberValue >>> 0,\n                (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)\n            ];\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, tempI64[0], true);\n            HEAP_DATA_VIEW.setInt32(result + 4, tempI64[1], true);\n        }\n        var utilMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            $emnapiSetValueI64: $emnapiSetValueI64,\n            _emnapi_call_finalizer: _emnapi_call_finalizer,\n            _emnapi_callback_into_module: _emnapi_callback_into_module,\n            _emnapi_ctx_decrease_waiting_request_counter: _emnapi_ctx_decrease_waiting_request_counter,\n            _emnapi_ctx_increase_waiting_request_counter: _emnapi_ctx_increase_waiting_request_counter,\n            _emnapi_get_node_version: _emnapi_get_node_version,\n            _emnapi_next_tick: _emnapi_next_tick,\n            _emnapi_runtime_keepalive_pop: _emnapi_runtime_keepalive_pop,\n            _emnapi_runtime_keepalive_push: _emnapi_runtime_keepalive_push,\n            _emnapi_set_immediate: _emnapi_set_immediate,\n            napi_clear_last_error: napi_clear_last_error,\n            napi_set_last_error: napi_set_last_error\n        });\n        function emnapiGetWorkerByPthreadPtr(pthreadPtr) {\n            var view = new DataView(wasmMemory.buffer);\n            /**\n             * wasi-sdk-20.0+threads\n             *\n             * struct pthread {\n             *   struct pthread *self;        // 0\n             *   struct pthread *prev, *next; // 4, 8\n             *   uintptr_t sysinfo;           // 12\n             *   uintptr_t canary;            // 16\n             *   int tid;                     // 20\n             *   // ...\n             * }\n             */\n            var tidOffset = 20;\n            var tid = view.getInt32(pthreadPtr + tidOffset, true);\n            var worker = PThread.pthreads[tid];\n            return worker;\n        }\n        /** @__sig vp */\n        function _emnapi_worker_unref(pthreadPtr) {\n            if (ENVIRONMENT_IS_PTHREAD)\n                return;\n            var worker = emnapiGetWorkerByPthreadPtr(pthreadPtr);\n            if (worker && typeof worker.unref === 'function') {\n                worker.unref();\n            }\n        }\n        /** @__sig vipp */\n        function _emnapi_async_send_js(type, callback, data) {\n            if (ENVIRONMENT_IS_PTHREAD) {\n                var postMessage_1 = napiModule.postMessage;\n                postMessage_1({\n                    __emnapi__: {\n                        type: 'async-send',\n                        payload: {\n                            callback: callback,\n                            data: data\n                        }\n                    }\n                });\n            }\n            else {\n                switch (type) {\n                    case 0:\n                        _emnapi_set_immediate(callback, data);\n                        break;\n                    case 1:\n                        _emnapi_next_tick(callback, data);\n                        break;\n                }\n            }\n        }\n        // function ptrToString (ptr: number): string {\n        //   return '0x' + ('00000000' + ptr.toString(16)).slice(-8)\n        // }\n        var uvThreadpoolReadyResolve;\n        var uvThreadpoolReady = new Promise(function (resolve) {\n            uvThreadpoolReadyResolve = function () {\n                uvThreadpoolReady.ready = true;\n                resolve();\n            };\n        });\n        uvThreadpoolReady.ready = false;\n        /** @__sig i */\n        function _emnapi_is_main_browser_thread() {\n            return (typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE) ? 1 : 0;\n        }\n        /** @__sig vppi */\n        function _emnapi_after_uvthreadpool_ready(callback, q, type) {\n            if (uvThreadpoolReady.ready) {\n                (wasmTable.get(callback))(q, type);\n            }\n            else {\n                uvThreadpoolReady.then(function () {\n                    (wasmTable.get(callback))(q, type);\n                });\n            }\n        }\n        /** @__sig vpi */\n        function _emnapi_tell_js_uvthreadpool(threads, size) {\n            var p = [];\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            var _loop_1 = function (i) {\n                var pthreadPtr = HEAP_DATA_VIEW.getInt32(threads + i * 4, true);\n                var worker = emnapiGetWorkerByPthreadPtr(pthreadPtr);\n                p.push(new Promise(function (resolve) {\n                    var handler = function (e) {\n                        var data = ENVIRONMENT_IS_NODE ? e : e.data;\n                        var __emnapi__ = data.__emnapi__;\n                        if (__emnapi__ && __emnapi__.type === 'async-thread-ready') {\n                            resolve();\n                            if (worker && typeof worker.unref === 'function') {\n                                worker.unref();\n                            }\n                            if (ENVIRONMENT_IS_NODE) {\n                                worker.off('message', handler);\n                            }\n                            else {\n                                worker.removeEventListener('message', handler);\n                            }\n                        }\n                    };\n                    if (ENVIRONMENT_IS_NODE) {\n                        worker.on('message', handler);\n                    }\n                    else {\n                        worker.addEventListener('message', handler);\n                    }\n                }));\n            };\n            for (var i = 0; i < size; i++) {\n                _loop_1(i);\n            }\n            Promise.all(p).then(uvThreadpoolReadyResolve);\n        }\n        /** @__sig v */\n        function _emnapi_emit_async_thread_ready() {\n            if (!ENVIRONMENT_IS_PTHREAD)\n                return;\n            var postMessage = napiModule.postMessage;\n            postMessage({\n                __emnapi__: {\n                    type: 'async-thread-ready',\n                    payload: {}\n                }\n            });\n        }\n        var asyncMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            _emnapi_after_uvthreadpool_ready: _emnapi_after_uvthreadpool_ready,\n            _emnapi_async_send_js: _emnapi_async_send_js,\n            _emnapi_emit_async_thread_ready: _emnapi_emit_async_thread_ready,\n            _emnapi_is_main_browser_thread: _emnapi_is_main_browser_thread,\n            _emnapi_tell_js_uvthreadpool: _emnapi_tell_js_uvthreadpool,\n            _emnapi_worker_unref: _emnapi_worker_unref\n        });\n        /* eslint-disable @typescript-eslint/indent */\n        /** @__sig ipjp */\n        function napi_adjust_external_memory(env, change_in_bytes, adjusted_value) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            var envObject = emnapiCtx.envStore.get(env);\n            if (!adjusted_value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var change_in_bytes_number = Number(change_in_bytes);\n            if (change_in_bytes_number < 0) {\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            }\n            var old_size = wasmMemory.buffer.byteLength;\n            var new_size = old_size + change_in_bytes_number;\n            new_size = new_size + ((65536 - new_size % 65536) % 65536);\n            if (wasmMemory.grow((new_size - old_size + 65535) >> 16) === -1) {\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            if (emnapiCtx.feature.supportBigInt) {\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setBigInt64(adjusted_value, BigInt(wasmMemory.buffer.byteLength), true);\n            }\n            else {\n                $emnapiSetValueI64(adjusted_value, wasmMemory.buffer.byteLength);\n            }\n            return envObject.clearLastError();\n        }\n        var memoryMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_adjust_external_memory: napi_adjust_external_memory\n        });\n        /**\n         * @__postset\n         * ```\n         * emnapiAWST.init();\n         * ```\n         */\n        var emnapiAWST = {\n            idGen: {},\n            values: [undefined],\n            queued: new Set(),\n            pending: [],\n            init: function () {\n                var idGen = {\n                    nextId: 1,\n                    list: [],\n                    generate: function () {\n                        var id;\n                        if (idGen.list.length) {\n                            id = idGen.list.shift();\n                        }\n                        else {\n                            id = idGen.nextId;\n                            idGen.nextId++;\n                        }\n                        return id;\n                    },\n                    reuse: function (id) {\n                        idGen.list.push(id);\n                    }\n                };\n                emnapiAWST.idGen = idGen;\n                emnapiAWST.values = [undefined];\n                emnapiAWST.queued = new Set();\n                emnapiAWST.pending = [];\n            },\n            create: function (env, resource, resourceName, execute, complete, data) {\n                var asyncId = 0;\n                var triggerAsyncId = 0;\n                if (emnapiNodeBinding) {\n                    var asyncContext = emnapiNodeBinding.node.emitAsyncInit(resource, resourceName, -1);\n                    asyncId = asyncContext.asyncId;\n                    triggerAsyncId = asyncContext.triggerAsyncId;\n                }\n                var id = emnapiAWST.idGen.generate();\n                emnapiAWST.values[id] = {\n                    env: env,\n                    id: id,\n                    resource: resource,\n                    asyncId: asyncId,\n                    triggerAsyncId: triggerAsyncId,\n                    status: 0,\n                    execute: execute,\n                    complete: complete,\n                    data: data\n                };\n                return id;\n            },\n            callComplete: function (work, status) {\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var complete = work.complete;\n                var env = work.env;\n                var data = work.data;\n                var callback = function () {\n                    if (!complete)\n                        return;\n                    var envObject = emnapiCtx.envStore.get(env);\n                    var scope = emnapiCtx.openScope(envObject);\n                    try {\n                        envObject.callbackIntoModule(true, function () {\n                            (wasmTable.get(complete))(env, status, data);\n                        });\n                    }\n                    finally {\n                        emnapiCtx.closeScope(envObject, scope);\n                    }\n                };\n                if (emnapiNodeBinding) {\n                    emnapiNodeBinding.node.makeCallback(work.resource, callback, [], {\n                        asyncId: work.asyncId,\n                        triggerAsyncId: work.triggerAsyncId\n                    });\n                }\n                else {\n                    callback();\n                }\n            },\n            queue: function (id) {\n                var work = emnapiAWST.values[id];\n                if (!work)\n                    return;\n                if (work.status === 0) {\n                    work.status = 1;\n                    if (emnapiAWST.queued.size >= (Math.abs(emnapiAsyncWorkPoolSize) || 4)) {\n                        emnapiAWST.pending.push(id);\n                        return;\n                    }\n                    emnapiAWST.queued.add(id);\n                    var env_1 = work.env;\n                    var data_1 = work.data;\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    var execute = work.execute;\n                    work.status = 2;\n                    emnapiCtx.feature.setImmediate(function () {\n                        (wasmTable.get(execute))(env_1, data_1);\n                        emnapiAWST.queued.delete(id);\n                        work.status = 3;\n                        emnapiCtx.feature.setImmediate(function () {\n                            emnapiAWST.callComplete(work, 0 /* napi_status.napi_ok */);\n                        });\n                        if (emnapiAWST.pending.length > 0) {\n                            var nextWorkId = emnapiAWST.pending.shift();\n                            emnapiAWST.values[nextWorkId].status = 0;\n                            emnapiAWST.queue(nextWorkId);\n                        }\n                    });\n                }\n            },\n            cancel: function (id) {\n                var index = emnapiAWST.pending.indexOf(id);\n                if (index !== -1) {\n                    var work_1 = emnapiAWST.values[id];\n                    if (work_1 && (work_1.status === 1)) {\n                        work_1.status = 4;\n                        emnapiAWST.pending.splice(index, 1);\n                        emnapiCtx.feature.setImmediate(function () {\n                            emnapiAWST.callComplete(work_1, 11 /* napi_status.napi_cancelled */);\n                        });\n                        return 0 /* napi_status.napi_ok */;\n                    }\n                    else {\n                        return 9 /* napi_status.napi_generic_failure */;\n                    }\n                }\n                return 9 /* napi_status.napi_generic_failure */;\n            },\n            remove: function (id) {\n                var work = emnapiAWST.values[id];\n                if (!work)\n                    return;\n                if (emnapiNodeBinding) {\n                    emnapiNodeBinding.node.emitAsyncDestroy({\n                        asyncId: work.asyncId,\n                        triggerAsyncId: work.triggerAsyncId\n                    });\n                }\n                emnapiAWST.values[id] = undefined;\n                emnapiAWST.idGen.reuse(id);\n            }\n        };\n        /** @__sig vppdp */\n        function _emnapi_node_emit_async_init(async_resource, async_resource_name, trigger_async_id, result) {\n            if (!emnapiNodeBinding)\n                return;\n            var resource = emnapiCtx.handleStore.get(async_resource).value;\n            var resource_name = emnapiCtx.handleStore.get(async_resource_name).value;\n            var asyncContext = emnapiNodeBinding.node.emitAsyncInit(resource, resource_name, trigger_async_id);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var asyncId = asyncContext.asyncId;\n            var triggerAsyncId = asyncContext.triggerAsyncId;\n            if (result) {\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setFloat64(result, asyncId, true);\n                HEAP_DATA_VIEW.setFloat64(result + 8, triggerAsyncId, true);\n            }\n        }\n        /** @__sig vdd */\n        function _emnapi_node_emit_async_destroy(async_id, trigger_async_id) {\n            if (!emnapiNodeBinding)\n                return;\n            emnapiNodeBinding.node.emitAsyncDestroy({\n                asyncId: async_id,\n                triggerAsyncId: trigger_async_id\n            });\n        }\n        /* vpddp export function _emnapi_node_open_callback_scope (async_resource: napi_value, async_id: double, trigger_async_id: double, result: Pointer<int64_t>): void {\n          if (!emnapiNodeBinding || !result) return\n          const resource = emnapiCtx.handleStore.get(async_resource)!.value\n          // eslint-disable-next-line @typescript-eslint/no-unused-vars\n          const nativeCallbackScopePointer = emnapiNodeBinding.node.openCallbackScope(resource, {\n            asyncId: async_id,\n            triggerAsyncId: trigger_async_id\n          })\n    \n          from64('result')\n          $_TODO_makeSetValue('result', 0, 'nativeCallbackScopePointer', 'i64')\n        }\n    \n        vp\n        export function _emnapi_node_close_callback_scope (scope: Pointer<int64_t>): void {\n          if (!emnapiNodeBinding || !scope) return\n          from64('scope')\n          const nativeCallbackScopePointer = $_TODO_makeGetValue('scope', 0, 'i64')\n          emnapiNodeBinding.node.closeCallbackScope(BigInt(nativeCallbackScopePointer))\n        } */\n        /** @__sig ipppppddp */\n        function _emnapi_node_make_callback(env, async_resource, cb, argv, size, async_id, trigger_async_id, result) {\n            var i = 0;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v;\n            if (!emnapiNodeBinding)\n                return;\n            var resource = emnapiCtx.handleStore.get(async_resource).value;\n            var callback = emnapiCtx.handleStore.get(cb).value;\n            size = size >>> 0;\n            var arr = Array(size);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            for (; i < size; i++) {\n                var argVal = HEAP_DATA_VIEW.getInt32(argv + i * 4, true);\n                arr[i] = emnapiCtx.handleStore.get(argVal).value;\n            }\n            var ret = emnapiNodeBinding.node.makeCallback(resource, callback, arr, {\n                asyncId: async_id,\n                triggerAsyncId: trigger_async_id\n            });\n            if (result) {\n                var envObject = emnapiCtx.envStore.get(env);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                v = envObject.ensureHandleId(ret);\n                HEAP_DATA_VIEW.setInt32(result, v, true);\n            }\n        }\n        /** @__sig ippp */\n        function _emnapi_async_init_js(async_resource, async_resource_name, result) {\n            if (!emnapiNodeBinding) {\n                return 9 /* napi_status.napi_generic_failure */;\n            }\n            var resource;\n            if (async_resource) {\n                resource = Object(emnapiCtx.handleStore.get(async_resource).value);\n            }\n            var name = emnapiCtx.handleStore.get(async_resource_name).value;\n            var ret = emnapiNodeBinding.napi.asyncInit(resource, name);\n            if (ret.status !== 0)\n                return ret.status;\n            var numberValue = ret.value;\n            if (!((numberValue >= (BigInt(-1) * (BigInt(1) << BigInt(63)))) && (numberValue < (BigInt(1) << BigInt(63))))) {\n                numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1));\n                if (numberValue >= (BigInt(1) << BigInt(63))) {\n                    numberValue = numberValue - (BigInt(1) << BigInt(64));\n                }\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var low = Number(numberValue & BigInt(0xffffffff));\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var high = Number(numberValue >> BigInt(32));\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, low, true);\n            HEAP_DATA_VIEW.setInt32(result + 4, high, true);\n            return 0 /* napi_status.napi_ok */;\n        }\n        /** @__sig ip */\n        function _emnapi_async_destroy_js(async_context) {\n            if (!emnapiNodeBinding) {\n                return 9 /* napi_status.napi_generic_failure */;\n            }\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            var low = HEAP_DATA_VIEW.getInt32(async_context, true);\n            var high = HEAP_DATA_VIEW.getInt32(async_context + 4, true);\n            var pointer = BigInt(low >>> 0) | (BigInt(high) << BigInt(32));\n            var ret = emnapiNodeBinding.napi.asyncDestroy(pointer);\n            if (ret.status !== 0)\n                return ret.status;\n            return 0 /* napi_status.napi_ok */;\n        }\n        // https://github.com/nodejs/node-addon-api/pull/1283\n        /** @__sig ipppp */\n        function napi_open_callback_scope(env, ignored, async_context_handle, result) {\n            throw new Error('napi_open_callback_scope has not been implemented yet');\n        }\n        /** @__sig ipp */\n        function napi_close_callback_scope(env, scope) {\n            throw new Error('napi_close_callback_scope has not been implemented yet');\n        }\n        /** @__sig ippppppp */\n        function napi_make_callback(env, async_context, recv, func, argc, argv, result) {\n            var i = 0;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!emnapiNodeBinding) {\n                    return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n                }\n                if (!recv)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (argc > 0) {\n                    if (!argv)\n                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var v8recv = Object(emnapiCtx.handleStore.get(recv).value);\n                var v8func = emnapiCtx.handleStore.get(func).value;\n                if (typeof v8func !== 'function') {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                var low = HEAP_DATA_VIEW.getInt32(async_context, true);\n                var high = HEAP_DATA_VIEW.getInt32(async_context + 4, true);\n                var ctx = BigInt(low >>> 0) | (BigInt(high) << BigInt(32));\n                argc = argc >>> 0;\n                var arr = Array(argc);\n                for (; i < argc; i++) {\n                    var argVal = HEAP_DATA_VIEW.getInt32(argv + i * 4, true);\n                    arr[i] = emnapiCtx.handleStore.get(argVal).value;\n                }\n                var ret = emnapiNodeBinding.napi.makeCallback(ctx, v8recv, v8func, arr);\n                if (ret.error) {\n                    throw ret.error;\n                }\n                if (ret.status !== 0 /* napi_status.napi_ok */)\n                    return envObject.setLastError(ret.status);\n                if (result) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    v = envObject.ensureHandleId(ret.value);\n                    HEAP_DATA_VIEW.setInt32(result, v, true);\n                }\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig vp */\n        function _emnapi_env_check_gc_access(env) {\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n        }\n        var nodeMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            _emnapi_async_destroy_js: _emnapi_async_destroy_js,\n            _emnapi_async_init_js: _emnapi_async_init_js,\n            _emnapi_env_check_gc_access: _emnapi_env_check_gc_access,\n            _emnapi_node_emit_async_destroy: _emnapi_node_emit_async_destroy,\n            _emnapi_node_emit_async_init: _emnapi_node_emit_async_init,\n            _emnapi_node_make_callback: _emnapi_node_make_callback,\n            napi_close_callback_scope: napi_close_callback_scope,\n            napi_make_callback: napi_make_callback,\n            napi_open_callback_scope: napi_open_callback_scope\n        });\n        /**\n         * @__deps malloc\n         * @__deps free\n         * @__postset\n         * ```\n         * emnapiTSFN.init();\n         * ```\n         */\n        var emnapiTSFN = {\n            offset: {\n                /* napi_ref */ resource: 0,\n                /* double */ async_id: 8,\n                /* double */ trigger_async_id: 16,\n                /* size_t */ queue_size: 24,\n                /* void* */ queue: 1 * 4 + 24,\n                /* size_t */ thread_count: 2 * 4 + 24,\n                /* bool */ is_closing: 3 * 4 + 24,\n                /* atomic_uchar */ dispatch_state: 3 * 4 + 28,\n                /* void* */ context: 3 * 4 + 32,\n                /* size_t */ max_queue_size: 4 * 4 + 32,\n                /* napi_ref */ ref: 5 * 4 + 32,\n                /* napi_env */ env: 6 * 4 + 32,\n                /* void* */ finalize_data: 7 * 4 + 32,\n                /* napi_finalize */ finalize_cb: 8 * 4 + 32,\n                /* napi_threadsafe_function_call_js */ call_js_cb: 9 * 4 + 32,\n                /* bool */ handles_closing: 10 * 4 + 32,\n                /* bool */ async_ref: 10 * 4 + 36,\n                /* int32_t */ mutex: 10 * 4 + 40,\n                /* int32_t */ cond: 10 * 4 + 44,\n                end: 10 * 4 + 48\n            },\n            init: function () {\n                if (typeof PThread !== 'undefined') {\n                    PThread.unusedWorkers.forEach(emnapiTSFN.addListener);\n                    PThread.runningWorkers.forEach(emnapiTSFN.addListener);\n                    var __original_getNewWorker_1 = PThread.getNewWorker;\n                    PThread.getNewWorker = function () {\n                        var r = __original_getNewWorker_1.apply(this, arguments);\n                        emnapiTSFN.addListener(r);\n                        return r;\n                    };\n                }\n            },\n            addListener: function (worker) {\n                if (!worker)\n                    return false;\n                if (worker._emnapiTSFNListener)\n                    return true;\n                var handler = function (e) {\n                    var data = ENVIRONMENT_IS_NODE ? e : e.data;\n                    var __emnapi__ = data.__emnapi__;\n                    if (__emnapi__) {\n                        var type = __emnapi__.type;\n                        var payload = __emnapi__.payload;\n                        if (type === 'tsfn-send') {\n                            emnapiTSFN.dispatch(payload.tsfn);\n                        }\n                    }\n                };\n                var dispose = function () {\n                    if (ENVIRONMENT_IS_NODE) {\n                        worker.off('message', handler);\n                    }\n                    else {\n                        worker.removeEventListener('message', handler, false);\n                    }\n                    delete worker._emnapiTSFNListener;\n                };\n                worker._emnapiTSFNListener = { handler: handler, dispose: dispose };\n                if (ENVIRONMENT_IS_NODE) {\n                    worker.on('message', handler);\n                }\n                else {\n                    worker.addEventListener('message', handler, false);\n                }\n                return true;\n            },\n            initQueue: function (func) {\n                var size = 2 * 4;\n                var queue = _malloc(size);\n                if (!queue)\n                    return false;\n                new Uint8Array(wasmMemory.buffer, queue, size).fill(0);\n                emnapiTSFN.storeSizeTypeValue(func + emnapiTSFN.offset.queue, queue, false);\n                return true;\n            },\n            destroyQueue: function (func) {\n                var queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);\n                if (queue) {\n                    _free(queue);\n                }\n            },\n            pushQueue: function (func, data) {\n                var queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);\n                var head = emnapiTSFN.loadSizeTypeValue(queue, false);\n                var tail = emnapiTSFN.loadSizeTypeValue(queue + 4, false);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var size = 2 * 4;\n                var node = _malloc(size);\n                if (!node)\n                    throw new Error('OOM');\n                emnapiTSFN.storeSizeTypeValue(node, data, false);\n                emnapiTSFN.storeSizeTypeValue(node + 4, 0, false);\n                if (head === 0 && tail === 0) {\n                    emnapiTSFN.storeSizeTypeValue(queue, node, false);\n                    emnapiTSFN.storeSizeTypeValue(queue + 4, node, false);\n                }\n                else {\n                    emnapiTSFN.storeSizeTypeValue(tail + 4, node, false);\n                    emnapiTSFN.storeSizeTypeValue(queue + 4, node, false);\n                }\n                emnapiTSFN.addQueueSize(func);\n            },\n            shiftQueue: function (func) {\n                var queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false);\n                var head = emnapiTSFN.loadSizeTypeValue(queue, false);\n                if (head === 0)\n                    return 0;\n                var node = head;\n                var next = emnapiTSFN.loadSizeTypeValue(head + 4, false);\n                emnapiTSFN.storeSizeTypeValue(queue, next, false);\n                if (next === 0) {\n                    emnapiTSFN.storeSizeTypeValue(queue + 4, 0, false);\n                }\n                emnapiTSFN.storeSizeTypeValue(node + 4, 0, false);\n                var value = emnapiTSFN.loadSizeTypeValue(node, false);\n                _free(node);\n                emnapiTSFN.subQueueSize(func);\n                return value;\n            },\n            push: function (func, data, mode) {\n                var mutex = emnapiTSFN.getMutex(func);\n                var cond = emnapiTSFN.getCond(func);\n                var waitCondition = function () {\n                    var queueSize = emnapiTSFN.getQueueSize(func);\n                    var maxSize = emnapiTSFN.getMaxQueueSize(func);\n                    var isClosing = emnapiTSFN.getIsClosing(func);\n                    return queueSize >= maxSize && maxSize > 0 && !isClosing;\n                };\n                var isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE;\n                return mutex.execute(function () {\n                    while (waitCondition()) {\n                        if (mode === 0 /* napi_threadsafe_function_call_mode.napi_tsfn_nonblocking */) {\n                            return 15 /* napi_status.napi_queue_full */;\n                        }\n                        /**\n                         * Browser JS main thread can not use `Atomics.wait`\n                         *\n                         * Related:\n                         * https://github.com/nodejs/node/pull/32689\n                         * https://github.com/nodejs/node/pull/33453\n                         */\n                        if (isBrowserMain) {\n                            return 21 /* napi_status.napi_would_deadlock */;\n                        }\n                        cond.wait();\n                    }\n                    if (emnapiTSFN.getIsClosing(func)) {\n                        if (emnapiTSFN.getThreadCount(func) === 0) {\n                            return 1 /* napi_status.napi_invalid_arg */;\n                        }\n                        else {\n                            emnapiTSFN.subThreadCount(func);\n                            return 16 /* napi_status.napi_closing */;\n                        }\n                    }\n                    else {\n                        emnapiTSFN.pushQueue(func, data);\n                        emnapiTSFN.send(func);\n                        return 0 /* napi_status.napi_ok */;\n                    }\n                });\n            },\n            getMutex: function (func) {\n                var index = func + emnapiTSFN.offset.mutex;\n                var mutex = {\n                    lock: function () {\n                        var isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE;\n                        var i32a = new Int32Array(wasmMemory.buffer, index, 1);\n                        if (isBrowserMain) {\n                            while (true) {\n                                var oldValue = Atomics.compareExchange(i32a, 0, 0, 1);\n                                if (oldValue === 0) {\n                                    return;\n                                }\n                            }\n                        }\n                        else {\n                            while (true) {\n                                var oldValue = Atomics.compareExchange(i32a, 0, 0, 1);\n                                if (oldValue === 0) {\n                                    return;\n                                }\n                                Atomics.wait(i32a, 0, 1);\n                            }\n                        }\n                    },\n                    /* lockAsync () {\n                      return new Promise<void>(resolve => {\n                        const again = (): void => { fn() }\n                        const fn = (): void => {\n                          const i32a = new Int32Array(wasmMemory.buffer, index, 1)\n                          const oldValue = Atomics.compareExchange(i32a, 0, 0, 1)\n                          if (oldValue === 0) {\n                            resolve()\n                            return\n                          }\n                          (Atomics as any).waitAsync(i32a, 0, 1).value.then(again)\n                        }\n                        fn()\n                      })\n                    }, */\n                    unlock: function () {\n                        var i32a = new Int32Array(wasmMemory.buffer, index, 1);\n                        var oldValue = Atomics.compareExchange(i32a, 0, 1, 0);\n                        if (oldValue !== 1) {\n                            throw new Error('Tried to unlock while not holding the mutex');\n                        }\n                        Atomics.notify(i32a, 0, 1);\n                    },\n                    execute: function (fn) {\n                        mutex.lock();\n                        try {\n                            return fn();\n                        }\n                        finally {\n                            mutex.unlock();\n                        }\n                    } /* ,\n                    executeAsync<T> (fn: () => Promise<T>): Promise<T> {\n                      return mutex.lockAsync().then(() => {\n                        const r = fn()\n                        mutex.unlock()\n                        return r\n                      }, (err) => {\n                        mutex.unlock()\n                        throw err\n                      })\n                    } */\n                };\n                return mutex;\n            },\n            getCond: function (func) {\n                var index = func + emnapiTSFN.offset.cond;\n                var mutex = emnapiTSFN.getMutex(func);\n                var cond = {\n                    wait: function () {\n                        var i32a = new Int32Array(wasmMemory.buffer, index, 1);\n                        var value = Atomics.load(i32a, 0);\n                        mutex.unlock();\n                        Atomics.wait(i32a, 0, value);\n                        mutex.lock();\n                    },\n                    /* waitAsync () {\n                      const i32a = new Int32Array(wasmMemory.buffer, index, 1)\n                      const value = Atomics.load(i32a, 0)\n                      mutex.unlock()\n                      const lock = (): Promise<void> => mutex.lockAsync()\n                      try {\n                        return (Atomics as any).waitAsync(i32a, 0, value).value.then(lock, lock)\n                      } catch (err) {\n                        return lock()\n                      }\n                    }, */\n                    signal: function () {\n                        var i32a = new Int32Array(wasmMemory.buffer, index, 1);\n                        Atomics.add(i32a, 0, 1);\n                        Atomics.notify(i32a, 0, 1);\n                    }\n                };\n                return cond;\n            },\n            getQueueSize: function (func) {\n                return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue_size, true);\n            },\n            addQueueSize: function (func) {\n                var offset = emnapiTSFN.offset.queue_size;\n                var arr, index;\n                arr = new Uint32Array(wasmMemory.buffer);\n                index = (func + offset) >> 2;\n                Atomics.add(arr, index, 1);\n            },\n            subQueueSize: function (func) {\n                var offset = emnapiTSFN.offset.queue_size;\n                var arr, index;\n                arr = new Uint32Array(wasmMemory.buffer);\n                index = (func + offset) >> 2;\n                Atomics.sub(arr, index, 1);\n            },\n            getThreadCount: function (func) {\n                return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.thread_count, true);\n            },\n            addThreadCount: function (func) {\n                var offset = emnapiTSFN.offset.thread_count;\n                var arr, index;\n                arr = new Uint32Array(wasmMemory.buffer);\n                index = (func + offset) >> 2;\n                Atomics.add(arr, index, 1);\n            },\n            subThreadCount: function (func) {\n                var offset = emnapiTSFN.offset.thread_count;\n                var arr, index;\n                arr = new Uint32Array(wasmMemory.buffer);\n                index = (func + offset) >> 2;\n                Atomics.sub(arr, index, 1);\n            },\n            getIsClosing: function (func) {\n                return Atomics.load(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.is_closing) >> 2);\n            },\n            setIsClosing: function (func, value) {\n                Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.is_closing) >> 2, value);\n            },\n            getHandlesClosing: function (func) {\n                return Atomics.load(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.handles_closing) >> 2);\n            },\n            setHandlesClosing: function (func, value) {\n                Atomics.store(new Int32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.handles_closing) >> 2, value);\n            },\n            getDispatchState: function (func) {\n                return Atomics.load(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >> 2);\n            },\n            getContext: function (func) {\n                return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.context, false);\n            },\n            getMaxQueueSize: function (func) {\n                return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.max_queue_size, true);\n            },\n            getEnv: function (func) {\n                return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.env, false);\n            },\n            getCallJSCb: function (func) {\n                return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.call_js_cb, false);\n            },\n            getRef: function (func) {\n                return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.ref, false);\n            },\n            getResource: function (func) {\n                return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.resource, false);\n            },\n            getFinalizeCb: function (func) {\n                return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_cb, false);\n            },\n            getFinalizeData: function (func) {\n                return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_data, false);\n            },\n            loadSizeTypeValue: function (offset, unsigned) {\n                var ret;\n                var arr;\n                if (unsigned) {\n                    arr = new Uint32Array(wasmMemory.buffer);\n                    ret = Atomics.load(arr, offset >> 2);\n                    return ret;\n                }\n                else {\n                    arr = new Int32Array(wasmMemory.buffer);\n                    ret = Atomics.load(arr, offset >> 2);\n                    return ret;\n                }\n            },\n            storeSizeTypeValue: function (offset, value, unsigned) {\n                var arr;\n                if (unsigned) {\n                    arr = new Uint32Array(wasmMemory.buffer);\n                    Atomics.store(arr, offset >> 2, value);\n                    return undefined;\n                }\n                else {\n                    arr = new Int32Array(wasmMemory.buffer);\n                    Atomics.store(arr, offset >> 2, value >>> 0);\n                    return undefined;\n                }\n            },\n            destroy: function (func) {\n                emnapiTSFN.destroyQueue(func);\n                var env = emnapiTSFN.getEnv(func);\n                var envObject = emnapiCtx.envStore.get(env);\n                var ref = emnapiTSFN.getRef(func);\n                if (ref) {\n                    emnapiCtx.refStore.get(ref).dispose();\n                }\n                emnapiCtx.removeCleanupHook(envObject, emnapiTSFN.cleanup, func);\n                envObject.unref();\n                var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >> 2;\n                var arr = new Int32Array(wasmMemory.buffer);\n                if (Atomics.load(arr, asyncRefOffset)) {\n                    Atomics.store(arr, asyncRefOffset, 0);\n                    emnapiCtx.decreaseWaitingRequestCounter();\n                }\n                var resource = emnapiTSFN.getResource(func);\n                emnapiCtx.refStore.get(resource).dispose();\n                if (emnapiNodeBinding) {\n                    var view = new DataView(wasmMemory.buffer);\n                    var asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true);\n                    var triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true);\n                    _emnapi_node_emit_async_destroy(asyncId, triggerAsyncId);\n                }\n                _free(func);\n            },\n            emptyQueueAndDelete: function (func) {\n                var callJsCb = emnapiTSFN.getCallJSCb(func);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var context = emnapiTSFN.getContext(func);\n                var data;\n                while (emnapiTSFN.getQueueSize(func) > 0) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    data = emnapiTSFN.shiftQueue(func);\n                    if (callJsCb) {\n                        (wasmTable.get(callJsCb))(0, 0, context, data);\n                    }\n                }\n                emnapiTSFN.destroy(func);\n            },\n            finalize: function (func) {\n                var env = emnapiTSFN.getEnv(func);\n                var envObject = emnapiCtx.envStore.get(env);\n                emnapiCtx.openScope(envObject);\n                var finalize = emnapiTSFN.getFinalizeCb(func);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var data = emnapiTSFN.getFinalizeData(func);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var context = emnapiTSFN.getContext(func);\n                var f = function () {\n                    envObject.callFinalizerInternal(0, finalize, data, context);\n                };\n                try {\n                    if (finalize) {\n                        if (emnapiNodeBinding) {\n                            var resource = emnapiTSFN.getResource(func);\n                            var resource_value = emnapiCtx.refStore.get(resource).get();\n                            var resourceObject = emnapiCtx.handleStore.get(resource_value).value;\n                            var view = new DataView(wasmMemory.buffer);\n                            var asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true);\n                            var triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true);\n                            emnapiNodeBinding.node.makeCallback(resourceObject, f, [], {\n                                asyncId: asyncId,\n                                triggerAsyncId: triggerAsyncId\n                            });\n                        }\n                        else {\n                            f();\n                        }\n                    }\n                    emnapiTSFN.emptyQueueAndDelete(func);\n                }\n                finally {\n                    emnapiCtx.closeScope(envObject);\n                }\n            },\n            cleanup: function (func) {\n                emnapiTSFN.closeHandlesAndMaybeDelete(func, 1);\n            },\n            closeHandlesAndMaybeDelete: function (func, set_closing) {\n                var env = emnapiTSFN.getEnv(func);\n                var envObject = emnapiCtx.envStore.get(env);\n                emnapiCtx.openScope(envObject);\n                try {\n                    if (set_closing) {\n                        emnapiTSFN.getMutex(func).execute(function () {\n                            emnapiTSFN.setIsClosing(func, 1);\n                            if (emnapiTSFN.getMaxQueueSize(func) > 0) {\n                                emnapiTSFN.getCond(func).signal();\n                            }\n                        });\n                    }\n                    if (emnapiTSFN.getHandlesClosing(func)) {\n                        return;\n                    }\n                    emnapiTSFN.setHandlesClosing(func, 1);\n                    emnapiCtx.feature.setImmediate(function () {\n                        emnapiTSFN.finalize(func);\n                    });\n                }\n                finally {\n                    emnapiCtx.closeScope(envObject);\n                }\n            },\n            dispatchOne: function (func) {\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var data = 0;\n                var popped_value = false;\n                var has_more = false;\n                var mutex = emnapiTSFN.getMutex(func);\n                var cond = emnapiTSFN.getCond(func);\n                mutex.execute(function () {\n                    if (emnapiTSFN.getIsClosing(func)) {\n                        emnapiTSFN.closeHandlesAndMaybeDelete(func, 0);\n                    }\n                    else {\n                        var size = emnapiTSFN.getQueueSize(func);\n                        if (size > 0) {\n                            data = emnapiTSFN.shiftQueue(func);\n                            popped_value = true;\n                            var maxQueueSize = emnapiTSFN.getMaxQueueSize(func);\n                            if (size === maxQueueSize && maxQueueSize > 0) {\n                                cond.signal();\n                            }\n                            size--;\n                        }\n                        if (size === 0) {\n                            if (emnapiTSFN.getThreadCount(func) === 0) {\n                                emnapiTSFN.setIsClosing(func, 1);\n                                if (emnapiTSFN.getMaxQueueSize(func) > 0) {\n                                    cond.signal();\n                                }\n                                emnapiTSFN.closeHandlesAndMaybeDelete(func, 0);\n                            }\n                        }\n                        else {\n                            has_more = true;\n                        }\n                    }\n                });\n                if (popped_value) {\n                    var env = emnapiTSFN.getEnv(func);\n                    var envObject_1 = emnapiCtx.envStore.get(env);\n                    emnapiCtx.openScope(envObject_1);\n                    var f = function () {\n                        envObject_1.callbackIntoModule(false, function () {\n                            var callJsCb = emnapiTSFN.getCallJSCb(func);\n                            var ref = emnapiTSFN.getRef(func);\n                            var js_callback = ref ? emnapiCtx.refStore.get(ref).get() : 0;\n                            if (callJsCb) {\n                                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                                var context = emnapiTSFN.getContext(func);\n                                (wasmTable.get(callJsCb))(env, js_callback, context, data);\n                            }\n                            else {\n                                var jsCallback = js_callback ? emnapiCtx.handleStore.get(js_callback).value : null;\n                                if (typeof jsCallback === 'function') {\n                                    jsCallback();\n                                }\n                            }\n                        });\n                    };\n                    try {\n                        if (emnapiNodeBinding) {\n                            var resource = emnapiTSFN.getResource(func);\n                            var resource_value = emnapiCtx.refStore.get(resource).get();\n                            var resourceObject = emnapiCtx.handleStore.get(resource_value).value;\n                            var view = new DataView(wasmMemory.buffer);\n                            emnapiNodeBinding.node.makeCallback(resourceObject, f, [], {\n                                asyncId: view.getFloat64(func + emnapiTSFN.offset.async_id, true),\n                                triggerAsyncId: view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true)\n                            });\n                        }\n                        else {\n                            f();\n                        }\n                    }\n                    finally {\n                        emnapiCtx.closeScope(envObject_1);\n                    }\n                }\n                return has_more;\n            },\n            dispatch: function (func) {\n                var has_more = true;\n                var iterations_left = 1000;\n                var ui32a = new Uint32Array(wasmMemory.buffer);\n                var index = (func + emnapiTSFN.offset.dispatch_state) >> 2;\n                while (has_more && --iterations_left !== 0) {\n                    Atomics.store(ui32a, index, 1);\n                    has_more = emnapiTSFN.dispatchOne(func);\n                    if (Atomics.exchange(ui32a, index, 0) !== 1) {\n                        has_more = true;\n                    }\n                }\n                if (has_more) {\n                    emnapiTSFN.send(func);\n                }\n            },\n            send: function (func) {\n                var current_state = Atomics.or(new Uint32Array(wasmMemory.buffer), (func + emnapiTSFN.offset.dispatch_state) >> 2, 1 << 1);\n                if ((current_state & 1) === 1) {\n                    return;\n                }\n                if ((typeof ENVIRONMENT_IS_PTHREAD !== 'undefined') && ENVIRONMENT_IS_PTHREAD) {\n                    postMessage({\n                        __emnapi__: {\n                            type: 'tsfn-send',\n                            payload: {\n                                tsfn: func\n                            }\n                        }\n                    });\n                }\n                else {\n                    emnapiCtx.feature.setImmediate(function () {\n                        emnapiTSFN.dispatch(func);\n                    });\n                }\n            }\n        };\n        /** @__sig ippppppppppp */\n        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) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!async_resource_name)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            max_queue_size = max_queue_size >>> 0;\n            initial_thread_count = initial_thread_count >>> 0;\n            if (initial_thread_count === 0) {\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            }\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var ref = 0;\n            if (!func) {\n                if (!call_js_cb)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            }\n            else {\n                var funcValue = emnapiCtx.handleStore.get(func).value;\n                if (typeof funcValue !== 'function') {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                ref = emnapiCtx.createReference(envObject, func, 1, 1 /* Ownership.kUserland */).id;\n            }\n            var asyncResourceObject;\n            if (async_resource) {\n                asyncResourceObject = emnapiCtx.handleStore.get(async_resource).value;\n                if (asyncResourceObject == null) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                asyncResourceObject = Object(asyncResourceObject);\n            }\n            else {\n                asyncResourceObject = {};\n            }\n            var resource = envObject.ensureHandleId(asyncResourceObject);\n            var asyncResourceName = emnapiCtx.handleStore.get(async_resource_name).value;\n            if (typeof asyncResourceName === 'symbol') {\n                return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n            }\n            asyncResourceName = String(asyncResourceName);\n            var resource_name = envObject.ensureHandleId(asyncResourceName);\n            // tsfn create\n            var sizeofTSFN = emnapiTSFN.offset.end;\n            var tsfn = _malloc(sizeofTSFN);\n            if (!tsfn)\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            new Uint8Array(wasmMemory.buffer).subarray(tsfn, tsfn + sizeofTSFN).fill(0);\n            var resourceRef = emnapiCtx.createReference(envObject, resource, 1, 1 /* Ownership.kUserland */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var resource_ = resourceRef.id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(tsfn, resource_, true);\n            if (!emnapiTSFN.initQueue(tsfn)) {\n                _free(tsfn);\n                resourceRef.dispose();\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            _emnapi_node_emit_async_init(resource, resource_name, -1, tsfn + emnapiTSFN.offset.async_id);\n            HEAP_DATA_VIEW.setUint32(tsfn + emnapiTSFN.offset.thread_count, initial_thread_count, true);\n            HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.context, context, true);\n            HEAP_DATA_VIEW.setUint32(tsfn + emnapiTSFN.offset.max_queue_size, max_queue_size, true);\n            HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.ref, ref, true);\n            HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.env, env, true);\n            HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.finalize_data, thread_finalize_data, true);\n            HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.finalize_cb, thread_finalize_cb, true);\n            HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.call_js_cb, call_js_cb, true);\n            emnapiCtx.addCleanupHook(envObject, emnapiTSFN.cleanup, tsfn);\n            envObject.ref();\n            emnapiCtx.increaseWaitingRequestCounter();\n            HEAP_DATA_VIEW.setInt32(tsfn + emnapiTSFN.offset.async_ref, 1, true);\n            HEAP_DATA_VIEW.setInt32(result, tsfn, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipp */\n        function napi_get_threadsafe_function_context(func, result) {\n            if (!func || !result) {\n                abort();\n                return 1 /* napi_status.napi_invalid_arg */;\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var context = emnapiTSFN.getContext(func);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, context, true);\n            return 0 /* napi_status.napi_ok */;\n        }\n        /** @__sig ippi */\n        function napi_call_threadsafe_function(func, data, mode) {\n            if (!func) {\n                abort();\n                return 1 /* napi_status.napi_invalid_arg */;\n            }\n            return emnapiTSFN.push(func, data, mode);\n        }\n        /** @__sig ip */\n        function napi_acquire_threadsafe_function(func) {\n            if (!func) {\n                abort();\n                return 1 /* napi_status.napi_invalid_arg */;\n            }\n            var mutex = emnapiTSFN.getMutex(func);\n            return mutex.execute(function () {\n                if (emnapiTSFN.getIsClosing(func)) {\n                    return 16 /* napi_status.napi_closing */;\n                }\n                emnapiTSFN.addThreadCount(func);\n                return 0 /* napi_status.napi_ok */;\n            });\n        }\n        /** @__sig ipi */\n        function napi_release_threadsafe_function(func, mode) {\n            if (!func) {\n                abort();\n                return 1 /* napi_status.napi_invalid_arg */;\n            }\n            var mutex = emnapiTSFN.getMutex(func);\n            var cond = emnapiTSFN.getCond(func);\n            return mutex.execute(function () {\n                if (emnapiTSFN.getThreadCount(func) === 0) {\n                    return 1 /* napi_status.napi_invalid_arg */;\n                }\n                emnapiTSFN.subThreadCount(func);\n                if (emnapiTSFN.getThreadCount(func) === 0 || mode === 1 /* napi_threadsafe_function_release_mode.napi_tsfn_abort */) {\n                    var isClosing = emnapiTSFN.getIsClosing(func);\n                    if (!isClosing) {\n                        var isClosingValue = (mode === 1 /* napi_threadsafe_function_release_mode.napi_tsfn_abort */) ? 1 : 0;\n                        emnapiTSFN.setIsClosing(func, isClosingValue);\n                        if (isClosingValue && emnapiTSFN.getMaxQueueSize(func) > 0) {\n                            cond.signal();\n                        }\n                        emnapiTSFN.send(func);\n                    }\n                }\n                return 0 /* napi_status.napi_ok */;\n            });\n        }\n        /** @__sig ipp */\n        function napi_unref_threadsafe_function(env, func) {\n            if (!func) {\n                abort();\n                return 1 /* napi_status.napi_invalid_arg */;\n            }\n            var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >> 2;\n            var arr = new Int32Array(wasmMemory.buffer);\n            if (Atomics.load(arr, asyncRefOffset)) {\n                Atomics.store(arr, asyncRefOffset, 0);\n                emnapiCtx.decreaseWaitingRequestCounter();\n            }\n            return 0 /* napi_status.napi_ok */;\n        }\n        /** @__sig ipp */\n        function napi_ref_threadsafe_function(env, func) {\n            if (!func) {\n                abort();\n                return 1 /* napi_status.napi_invalid_arg */;\n            }\n            var asyncRefOffset = (func + emnapiTSFN.offset.async_ref) >> 2;\n            var arr = new Int32Array(wasmMemory.buffer);\n            if (!Atomics.load(arr, asyncRefOffset)) {\n                Atomics.store(arr, asyncRefOffset, 1);\n                emnapiCtx.increaseWaitingRequestCounter();\n            }\n            return 0 /* napi_status.napi_ok */;\n        }\n        var emnapiAWMT = {\n            unusedWorkers: [],\n            runningWorkers: [],\n            workQueue: [],\n            workerReady: null,\n            offset: {\n                /* napi_ref */ resource: 0,\n                /* double */ async_id: 8,\n                /* double */ trigger_async_id: 16,\n                /* napi_env */ env: 24,\n                /* void* */ data: 1 * 4 + 24,\n                /* napi_async_execute_callback */ execute: 2 * 4 + 24,\n                /* napi_async_complete_callback */ complete: 3 * 4 + 24,\n                end: 4 * 4 + 24\n            },\n            init: function () {\n                emnapiAWMT.unusedWorkers = [];\n                emnapiAWMT.runningWorkers = [];\n                emnapiAWMT.workQueue = [];\n                emnapiAWMT.workerReady = null;\n            },\n            addListener: function (worker) {\n                if (!worker)\n                    return false;\n                if (worker._emnapiAWMTListener)\n                    return true;\n                var handler = function (e) {\n                    var data = ENVIRONMENT_IS_NODE ? e : e.data;\n                    var __emnapi__ = data.__emnapi__;\n                    if (__emnapi__) {\n                        var type = __emnapi__.type;\n                        var payload = __emnapi__.payload;\n                        if (type === 'async-work-complete') {\n                            emnapiCtx.decreaseWaitingRequestCounter();\n                            emnapiAWMT.runningWorkers.splice(emnapiAWMT.runningWorkers.indexOf(worker), 1);\n                            emnapiAWMT.unusedWorkers.push(worker);\n                            emnapiAWMT.checkIdleWorker();\n                            emnapiAWMT.callComplete(payload.work, 0 /* napi_status.napi_ok */);\n                        }\n                        else if (type === 'async-work-queue') {\n                            emnapiAWMT.scheduleWork(payload.work);\n                        }\n                        else if (type === 'async-work-cancel') {\n                            emnapiAWMT.cancelWork(payload.work);\n                        }\n                    }\n                };\n                var dispose = function () {\n                    if (ENVIRONMENT_IS_NODE) {\n                        worker.off('message', handler);\n                    }\n                    else {\n                        worker.removeEventListener('message', handler, false);\n                    }\n                    delete worker._emnapiAWMTListener;\n                };\n                worker._emnapiAWMTListener = { handler: handler, dispose: dispose };\n                if (ENVIRONMENT_IS_NODE) {\n                    worker.on('message', handler);\n                }\n                else {\n                    worker.addEventListener('message', handler, false);\n                }\n                return true;\n            },\n            initWorkers: function (n) {\n                if (ENVIRONMENT_IS_PTHREAD) {\n                    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n                    return emnapiAWMT.workerReady || (emnapiAWMT.workerReady = Promise.resolve());\n                }\n                if (emnapiAWMT.workerReady)\n                    return emnapiAWMT.workerReady;\n                if (typeof onCreateWorker !== 'function') {\n                    throw new TypeError('`options.onCreateWorker` is not a function');\n                }\n                var promises = [];\n                var args = [];\n                if (!('emnapi_async_worker_create' in wasmInstance.exports)) {\n                    throw new TypeError('`emnapi_async_worker_create` is not exported, please try to add `--export=emnapi_async_worker_create` to linker flags');\n                }\n                for (var i = 0; i < n; ++i) {\n                    args.push(wasmInstance.exports.emnapi_async_worker_create());\n                }\n                try {\n                    var _loop_1 = function (i) {\n                        var worker = onCreateWorker({ type: 'async-work' });\n                        var p = PThread.loadWasmModuleToWorker(worker);\n                        emnapiAWMT.addListener(worker);\n                        promises.push(p.then(function () {\n                            if (typeof worker.unref === 'function') {\n                                worker.unref();\n                            }\n                        }));\n                        emnapiAWMT.unusedWorkers.push(worker);\n                        var arg = args[i];\n                        worker.threadBlockBase = arg;\n                        worker.postMessage({\n                            __emnapi__: {\n                                type: 'async-worker-init',\n                                payload: { arg: arg }\n                            }\n                        });\n                    };\n                    for (var i = 0; i < n; ++i) {\n                        _loop_1(i);\n                    }\n                }\n                catch (err) {\n                    for (var i = 0; i < n; ++i) {\n                        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                        var arg = args[i];\n                        _free(arg);\n                    }\n                    throw err;\n                }\n                emnapiAWMT.workerReady = Promise.all(promises);\n                return emnapiAWMT.workerReady;\n            },\n            checkIdleWorker: function () {\n                if (emnapiAWMT.unusedWorkers.length > 0 && emnapiAWMT.workQueue.length > 0) {\n                    var worker = emnapiAWMT.unusedWorkers.shift();\n                    var work = emnapiAWMT.workQueue.shift();\n                    emnapiAWMT.runningWorkers.push(worker);\n                    worker.postMessage({\n                        __emnapi__: {\n                            type: 'async-work-execute',\n                            payload: { work: work }\n                        }\n                    });\n                }\n            },\n            getResource: function (work) {\n                return emnapiTSFN.loadSizeTypeValue(work + emnapiAWMT.offset.resource, false);\n            },\n            getExecute: function (work) {\n                return emnapiTSFN.loadSizeTypeValue(work + emnapiAWMT.offset.execute, false);\n            },\n            getComplete: function (work) {\n                return emnapiTSFN.loadSizeTypeValue(work + emnapiAWMT.offset.complete, false);\n            },\n            getEnv: function (work) {\n                return emnapiTSFN.loadSizeTypeValue(work + emnapiAWMT.offset.env, false);\n            },\n            getData: function (work) {\n                return emnapiTSFN.loadSizeTypeValue(work + emnapiAWMT.offset.data, false);\n            },\n            scheduleWork: function (work) {\n                var _a;\n                if (ENVIRONMENT_IS_PTHREAD) {\n                    var postMessage_1 = napiModule.postMessage;\n                    postMessage_1({\n                        __emnapi__: {\n                            type: 'async-work-queue',\n                            payload: { work: work }\n                        }\n                    });\n                    return;\n                }\n                emnapiCtx.increaseWaitingRequestCounter();\n                emnapiAWMT.workQueue.push(work);\n                if ((_a = emnapiAWMT.workerReady) === null || _a === void 0 ? void 0 : _a.ready) {\n                    emnapiAWMT.checkIdleWorker();\n                }\n                else {\n                    var fail = function (err) {\n                        emnapiCtx.decreaseWaitingRequestCounter();\n                        throw err;\n                    };\n                    try {\n                        emnapiAWMT.initWorkers(_emnapi_async_work_pool_size()).then(function () {\n                            emnapiAWMT.workerReady.ready = true;\n                            emnapiAWMT.checkIdleWorker();\n                        }, fail);\n                    }\n                    catch (err) {\n                        fail(err);\n                    }\n                }\n            },\n            cancelWork: function (work) {\n                if (ENVIRONMENT_IS_PTHREAD) {\n                    var postMessage_2 = napiModule.postMessage;\n                    postMessage_2({\n                        __emnapi__: {\n                            type: 'async-work-cancel',\n                            payload: { work: work }\n                        }\n                    });\n                    return 0 /* napi_status.napi_ok */;\n                }\n                var index = emnapiAWMT.workQueue.indexOf(work);\n                if (index !== -1) {\n                    emnapiAWMT.workQueue.splice(index, 1);\n                    emnapiCtx.feature.setImmediate(function () {\n                        emnapiCtx.decreaseWaitingRequestCounter();\n                        emnapiAWMT.checkIdleWorker();\n                        emnapiAWMT.callComplete(work, 11 /* napi_status.napi_cancelled */);\n                    });\n                    return 0 /* napi_status.napi_ok */;\n                }\n                return 9 /* napi_status.napi_generic_failure */;\n            },\n            callComplete: function (work, status) {\n                var complete = emnapiAWMT.getComplete(work);\n                var env = emnapiAWMT.getEnv(work);\n                var data = emnapiAWMT.getData(work);\n                var envObject = emnapiCtx.envStore.get(env);\n                var scope = emnapiCtx.openScope(envObject);\n                var callback = function () {\n                    if (!complete)\n                        return;\n                    envObject.callbackIntoModule(true, function () {\n                        (wasmTable.get(complete))(env, status, data);\n                    });\n                };\n                try {\n                    if (emnapiNodeBinding) {\n                        var resource = emnapiAWMT.getResource(work);\n                        var resource_value = emnapiCtx.refStore.get(resource).get();\n                        var resourceObject = emnapiCtx.handleStore.get(resource_value).value;\n                        var view = new DataView(wasmMemory.buffer);\n                        var asyncId = view.getFloat64(work + emnapiAWMT.offset.async_id, true);\n                        var triggerAsyncId = view.getFloat64(work + emnapiAWMT.offset.trigger_async_id, true);\n                        emnapiNodeBinding.node.makeCallback(resourceObject, callback, [], {\n                            asyncId: asyncId,\n                            triggerAsyncId: triggerAsyncId\n                        });\n                    }\n                    else {\n                        callback();\n                    }\n                }\n                finally {\n                    emnapiCtx.closeScope(envObject, scope);\n                }\n            }\n        };\n        /** @__sig ippppppp */\n        var napi_create_async_work = singleThreadAsyncWork\n            ? function (env, resource, resource_name, execute, complete, data, result) {\n                if (!env)\n                    return 1 /* napi_status.napi_invalid_arg */;\n                // @ts-expect-error\n                var envObject = emnapiCtx.envStore.get(env);\n                envObject.checkGCAccess();\n                if (!execute)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var resourceObject;\n                if (resource) {\n                    resourceObject = Object(emnapiCtx.handleStore.get(resource).value);\n                }\n                else {\n                    resourceObject = {};\n                }\n                if (!resource_name)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var resourceName = String(emnapiCtx.handleStore.get(resource_name).value);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var id = emnapiAWST.create(env, resourceObject, resourceName, execute, complete, data);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, id, true);\n                return envObject.clearLastError();\n            }\n            : function (env, resource, resource_name, execute, complete, data, result) {\n                if (!env)\n                    return 1 /* napi_status.napi_invalid_arg */;\n                // @ts-expect-error\n                var envObject = emnapiCtx.envStore.get(env);\n                envObject.checkGCAccess();\n                if (!execute)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var resourceObject;\n                if (resource) {\n                    resourceObject = Object(emnapiCtx.handleStore.get(resource).value);\n                }\n                else {\n                    resourceObject = {};\n                }\n                if (!resource_name)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var sizeofAW = emnapiAWMT.offset.end;\n                var aw = _malloc(sizeofAW);\n                if (!aw)\n                    return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n                new Uint8Array(wasmMemory.buffer).subarray(aw, aw + sizeofAW).fill(0);\n                var s = envObject.ensureHandleId(resourceObject);\n                var resourceRef = emnapiCtx.createReference(envObject, s, 1, 1 /* Ownership.kUserland */);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var resource_ = resourceRef.id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(aw, resource_, true);\n                _emnapi_node_emit_async_init(s, resource_name, -1, aw + emnapiAWMT.offset.async_id);\n                HEAP_DATA_VIEW.setInt32(aw + emnapiAWMT.offset.env, env, true);\n                HEAP_DATA_VIEW.setInt32(aw + emnapiAWMT.offset.execute, execute, true);\n                HEAP_DATA_VIEW.setInt32(aw + emnapiAWMT.offset.complete, complete, true);\n                HEAP_DATA_VIEW.setInt32(aw + emnapiAWMT.offset.data, data, true);\n                HEAP_DATA_VIEW.setInt32(result, aw, true);\n                return envObject.clearLastError();\n            };\n        /** @__sig ipp */\n        var napi_delete_async_work = singleThreadAsyncWork\n            ? function (env, work) {\n                if (!env)\n                    return 1 /* napi_status.napi_invalid_arg */;\n                // @ts-expect-error\n                var envObject = emnapiCtx.envStore.get(env);\n                envObject.checkGCAccess();\n                if (!work)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                emnapiAWST.remove(work);\n                return envObject.clearLastError();\n            }\n            : function (env, work) {\n                if (!env)\n                    return 1 /* napi_status.napi_invalid_arg */;\n                // @ts-expect-error\n                var envObject = emnapiCtx.envStore.get(env);\n                envObject.checkGCAccess();\n                if (!work)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var resource = emnapiAWMT.getResource(work);\n                emnapiCtx.refStore.get(resource).dispose();\n                if (emnapiNodeBinding) {\n                    var view = new DataView(wasmMemory.buffer);\n                    var asyncId = view.getFloat64(work + emnapiAWMT.offset.async_id, true);\n                    var triggerAsyncId = view.getFloat64(work + emnapiAWMT.offset.trigger_async_id, true);\n                    _emnapi_node_emit_async_destroy(asyncId, triggerAsyncId);\n                }\n                _free(work);\n                return envObject.clearLastError();\n            };\n        /** @__sig ipp */\n        var napi_queue_async_work = singleThreadAsyncWork\n            ? function (env, work) {\n                if (!env)\n                    return 1 /* napi_status.napi_invalid_arg */;\n                var envObject = emnapiCtx.envStore.get(env);\n                if (!work)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                emnapiAWST.queue(work);\n                return envObject.clearLastError();\n            }\n            : function (env, work) {\n                if (!env)\n                    return 1 /* napi_status.napi_invalid_arg */;\n                var envObject = emnapiCtx.envStore.get(env);\n                if (!work)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                emnapiAWMT.scheduleWork(work);\n                return envObject.clearLastError();\n            };\n        /** @__sig ipp */\n        var napi_cancel_async_work = singleThreadAsyncWork\n            ? function (env, work) {\n                if (!env)\n                    return 1 /* napi_status.napi_invalid_arg */;\n                var envObject = emnapiCtx.envStore.get(env);\n                if (!work)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var status = emnapiAWST.cancel(work);\n                if (status === 0 /* napi_status.napi_ok */)\n                    return envObject.clearLastError();\n                return envObject.setLastError(status);\n            }\n            : function (env, work) {\n                if (!env)\n                    return 1 /* napi_status.napi_invalid_arg */;\n                var envObject = emnapiCtx.envStore.get(env);\n                if (!work)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var status = emnapiAWMT.cancelWork(work);\n                if (status === 0 /* napi_status.napi_ok */)\n                    return envObject.clearLastError();\n                return envObject.setLastError(status);\n            };\n        function initWorker(startArg) {\n            if (napiModule.childThread) {\n                if (typeof wasmInstance.exports.emnapi_async_worker_init !== 'function') {\n                    throw new TypeError('`emnapi_async_worker_init` is not exported, please try to add `--export=emnapi_async_worker_init` to linker flags');\n                }\n                wasmInstance.exports.emnapi_async_worker_init(startArg);\n            }\n            else {\n                throw new Error('startThread is only available in child threads');\n            }\n        }\n        function executeAsyncWork(work) {\n            if (!ENVIRONMENT_IS_PTHREAD)\n                return;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var execute = emnapiAWMT.getExecute(work);\n            var env = emnapiAWMT.getEnv(work);\n            var data = emnapiAWMT.getData(work);\n            (wasmTable.get(execute))(env, data);\n            var postMessage = napiModule.postMessage;\n            postMessage({\n                __emnapi__: {\n                    type: 'async-work-complete',\n                    payload: { work: work }\n                }\n            });\n        }\n        napiModule.initWorker = initWorker;\n        napiModule.executeAsyncWork = executeAsyncWork;\n        var asyncWorkMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_cancel_async_work: napi_cancel_async_work,\n            napi_create_async_work: napi_create_async_work,\n            napi_delete_async_work: napi_delete_async_work,\n            napi_queue_async_work: napi_queue_async_work\n        });\n        /**\n         * @__deps malloc\n         * @__deps free\n         * @__postset\n         * ```\n         * emnapiExternalMemory.init();\n         * ```\n         */\n        var emnapiExternalMemory = {\n            registry: typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(function (_pointer) { _free(_pointer); }) : undefined,\n            table: new WeakMap(),\n            wasmMemoryViewTable: new WeakMap(),\n            init: function () {\n                emnapiExternalMemory.registry = typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(function (_pointer) { _free(_pointer); }) : undefined;\n                emnapiExternalMemory.table = new WeakMap();\n                emnapiExternalMemory.wasmMemoryViewTable = new WeakMap();\n            },\n            isDetachedArrayBuffer: function (arrayBuffer) {\n                if (arrayBuffer.byteLength === 0) {\n                    try {\n                        // eslint-disable-next-line no-new\n                        new Uint8Array(arrayBuffer);\n                    }\n                    catch (_) {\n                        return true;\n                    }\n                }\n                return false;\n            },\n            getArrayBufferPointer: function (arrayBuffer, shouldCopy) {\n                var _a;\n                var info = {\n                    address: 0,\n                    ownership: 0 /* Ownership.kRuntime */,\n                    runtimeAllocated: 0\n                };\n                if (arrayBuffer === wasmMemory.buffer) {\n                    return info;\n                }\n                var isDetached = emnapiExternalMemory.isDetachedArrayBuffer(arrayBuffer);\n                if (emnapiExternalMemory.table.has(arrayBuffer)) {\n                    var cachedInfo = emnapiExternalMemory.table.get(arrayBuffer);\n                    if (isDetached) {\n                        cachedInfo.address = 0;\n                        return cachedInfo;\n                    }\n                    if (shouldCopy && cachedInfo.ownership === 0 /* Ownership.kRuntime */ && cachedInfo.runtimeAllocated === 1) {\n                        new Uint8Array(wasmMemory.buffer).set(new Uint8Array(arrayBuffer), cachedInfo.address);\n                    }\n                    return cachedInfo;\n                }\n                if (isDetached || (arrayBuffer.byteLength === 0)) {\n                    return info;\n                }\n                if (!shouldCopy) {\n                    return info;\n                }\n                var pointer = _malloc(arrayBuffer.byteLength);\n                if (!pointer)\n                    throw new Error('Out of memory');\n                new Uint8Array(wasmMemory.buffer).set(new Uint8Array(arrayBuffer), pointer);\n                info.address = pointer;\n                info.ownership = emnapiExternalMemory.registry ? 0 /* Ownership.kRuntime */ : 1 /* Ownership.kUserland */;\n                info.runtimeAllocated = 1;\n                emnapiExternalMemory.table.set(arrayBuffer, info);\n                (_a = emnapiExternalMemory.registry) === null || _a === void 0 ? void 0 : _a.register(arrayBuffer, pointer);\n                return info;\n            },\n            getOrUpdateMemoryView: function (view) {\n                if (view.buffer === wasmMemory.buffer) {\n                    if (!emnapiExternalMemory.wasmMemoryViewTable.has(view)) {\n                        emnapiExternalMemory.wasmMemoryViewTable.set(view, {\n                            Ctor: view.constructor,\n                            address: view.byteOffset,\n                            length: view instanceof DataView ? view.byteLength : view.length,\n                            ownership: 1 /* Ownership.kUserland */,\n                            runtimeAllocated: 0\n                        });\n                    }\n                    return view;\n                }\n                var maybeOldWasmMemory = emnapiExternalMemory.isDetachedArrayBuffer(view.buffer) ||\n                    ((typeof SharedArrayBuffer === 'function') && (view.buffer instanceof SharedArrayBuffer));\n                if (maybeOldWasmMemory && emnapiExternalMemory.wasmMemoryViewTable.has(view)) {\n                    var info = emnapiExternalMemory.wasmMemoryViewTable.get(view);\n                    var Ctor = info.Ctor;\n                    var newView = void 0;\n                    var Buffer = emnapiCtx.feature.Buffer;\n                    if (typeof Buffer === 'function' && Ctor === Buffer) {\n                        newView = Buffer.from(wasmMemory.buffer, info.address, info.length);\n                    }\n                    else {\n                        newView = new Ctor(wasmMemory.buffer, info.address, info.length);\n                    }\n                    emnapiExternalMemory.wasmMemoryViewTable.set(newView, info);\n                    return newView;\n                }\n                return view;\n            },\n            getViewPointer: function (view, shouldCopy) {\n                view = emnapiExternalMemory.getOrUpdateMemoryView(view);\n                if (view.buffer === wasmMemory.buffer) {\n                    if (emnapiExternalMemory.wasmMemoryViewTable.has(view)) {\n                        var _a = emnapiExternalMemory.wasmMemoryViewTable.get(view), address_1 = _a.address, ownership_1 = _a.ownership, runtimeAllocated_1 = _a.runtimeAllocated;\n                        return { address: address_1, ownership: ownership_1, runtimeAllocated: runtimeAllocated_1, view: view };\n                    }\n                    return { address: view.byteOffset, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0, view: view };\n                }\n                var _b = emnapiExternalMemory.getArrayBufferPointer(view.buffer, shouldCopy), address = _b.address, ownership = _b.ownership, runtimeAllocated = _b.runtimeAllocated;\n                return { address: address === 0 ? 0 : (address + view.byteOffset), ownership: ownership, runtimeAllocated: runtimeAllocated, view: view };\n            }\n        };\n        /* eslint-disable @typescript-eslint/indent */\n        /**\n         * @__postset\n         * ```\n         * emnapiString.init();\n         * ```\n         */\n        var emnapiString = {\n            utf8Decoder: undefined,\n            utf16Decoder: undefined,\n            init: function () {\n                var fallbackDecoder = {\n                    decode: function (bytes) {\n                        var inputIndex = 0;\n                        var pendingSize = Math.min(0x1000, bytes.length + 1);\n                        var pending = new Uint16Array(pendingSize);\n                        var chunks = [];\n                        var pendingIndex = 0;\n                        for (;;) {\n                            var more = inputIndex < bytes.length;\n                            if (!more || (pendingIndex >= pendingSize - 1)) {\n                                var subarray = pending.subarray(0, pendingIndex);\n                                var arraylike = subarray;\n                                chunks.push(String.fromCharCode.apply(null, arraylike));\n                                if (!more) {\n                                    return chunks.join('');\n                                }\n                                bytes = bytes.subarray(inputIndex);\n                                inputIndex = 0;\n                                pendingIndex = 0;\n                            }\n                            var byte1 = bytes[inputIndex++];\n                            if ((byte1 & 0x80) === 0) {\n                                pending[pendingIndex++] = byte1;\n                            }\n                            else if ((byte1 & 0xe0) === 0xc0) {\n                                var byte2 = bytes[inputIndex++] & 0x3f;\n                                pending[pendingIndex++] = ((byte1 & 0x1f) << 6) | byte2;\n                            }\n                            else if ((byte1 & 0xf0) === 0xe0) {\n                                var byte2 = bytes[inputIndex++] & 0x3f;\n                                var byte3 = bytes[inputIndex++] & 0x3f;\n                                pending[pendingIndex++] = ((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3;\n                            }\n                            else if ((byte1 & 0xf8) === 0xf0) {\n                                var byte2 = bytes[inputIndex++] & 0x3f;\n                                var byte3 = bytes[inputIndex++] & 0x3f;\n                                var byte4 = bytes[inputIndex++] & 0x3f;\n                                var codepoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;\n                                if (codepoint > 0xffff) {\n                                    codepoint -= 0x10000;\n                                    pending[pendingIndex++] = (codepoint >>> 10) & 0x3ff | 0xd800;\n                                    codepoint = 0xdc00 | codepoint & 0x3ff;\n                                }\n                                pending[pendingIndex++] = codepoint;\n                            }\n                            else ;\n                        }\n                    }\n                };\n                var utf8Decoder;\n                utf8Decoder = typeof TextDecoder === 'function' ? new TextDecoder() : fallbackDecoder;\n                emnapiString.utf8Decoder = utf8Decoder;\n                var fallbackDecoder2 = {\n                    decode: function (input) {\n                        var bytes = new Uint16Array(input.buffer, input.byteOffset, input.byteLength / 2);\n                        if (bytes.length <= 0x1000) {\n                            return String.fromCharCode.apply(null, bytes);\n                        }\n                        var chunks = [];\n                        var i = 0;\n                        var len = 0;\n                        for (; i < bytes.length; i += len) {\n                            len = Math.min(0x1000, bytes.length - i);\n                            chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, i + len)));\n                        }\n                        return chunks.join('');\n                    }\n                };\n                var utf16Decoder;\n                utf16Decoder = typeof TextDecoder === 'function' ? new TextDecoder('utf-16le') : fallbackDecoder2;\n                emnapiString.utf16Decoder = utf16Decoder;\n            },\n            lengthBytesUTF8: function (str) {\n                var c;\n                var len = 0;\n                for (var i = 0; i < str.length; ++i) {\n                    c = str.charCodeAt(i);\n                    if (c <= 0x7F) {\n                        len++;\n                    }\n                    else if (c <= 0x7FF) {\n                        len += 2;\n                    }\n                    else if (c >= 0xD800 && c <= 0xDFFF) {\n                        len += 4;\n                        ++i;\n                    }\n                    else {\n                        len += 3;\n                    }\n                }\n                return len;\n            },\n            UTF8ToString: function (ptr, length) {\n                if (!ptr || !length)\n                    return '';\n                ptr >>>= 0;\n                var HEAPU8 = new Uint8Array(wasmMemory.buffer);\n                var end = ptr;\n                if (length === -1) {\n                    for (; HEAPU8[end];)\n                        ++end;\n                }\n                else {\n                    end = ptr + (length >>> 0);\n                }\n                length = end - ptr;\n                if (length <= 16) {\n                    var idx = ptr;\n                    var str = '';\n                    while (idx < end) {\n                        var u0 = HEAPU8[idx++];\n                        if (!(u0 & 0x80)) {\n                            str += String.fromCharCode(u0);\n                            continue;\n                        }\n                        var u1 = HEAPU8[idx++] & 63;\n                        if ((u0 & 0xE0) === 0xC0) {\n                            str += String.fromCharCode(((u0 & 31) << 6) | u1);\n                            continue;\n                        }\n                        var u2 = HEAPU8[idx++] & 63;\n                        if ((u0 & 0xF0) === 0xE0) {\n                            u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;\n                        }\n                        else {\n                            u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (HEAPU8[idx++] & 63);\n                        }\n                        if (u0 < 0x10000) {\n                            str += String.fromCharCode(u0);\n                        }\n                        else {\n                            var ch = u0 - 0x10000;\n                            str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));\n                        }\n                    }\n                    return str;\n                }\n                return emnapiString.utf8Decoder.decode(((typeof SharedArrayBuffer === \"function\" && HEAPU8.buffer instanceof SharedArrayBuffer) || (Object.prototype.toString.call(HEAPU8.buffer.constructor) === \"[object SharedArrayBuffer]\")) ? HEAPU8.slice(ptr, end) : HEAPU8.subarray(ptr, end));\n            },\n            stringToUTF8: function (str, outPtr, maxBytesToWrite) {\n                var HEAPU8 = new Uint8Array(wasmMemory.buffer);\n                var outIdx = outPtr;\n                outIdx >>>= 0;\n                if (!(maxBytesToWrite > 0)) {\n                    return 0;\n                }\n                var startIdx = outIdx;\n                var endIdx = outIdx + maxBytesToWrite - 1;\n                for (var i = 0; i < str.length; ++i) {\n                    var u = str.charCodeAt(i);\n                    if (u >= 0xD800 && u <= 0xDFFF) {\n                        var u1 = str.charCodeAt(++i);\n                        u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);\n                    }\n                    if (u <= 0x7F) {\n                        if (outIdx >= endIdx)\n                            break;\n                        HEAPU8[outIdx++] = u;\n                    }\n                    else if (u <= 0x7FF) {\n                        if (outIdx + 1 >= endIdx)\n                            break;\n                        HEAPU8[outIdx++] = 0xC0 | (u >> 6);\n                        HEAPU8[outIdx++] = 0x80 | (u & 63);\n                    }\n                    else if (u <= 0xFFFF) {\n                        if (outIdx + 2 >= endIdx)\n                            break;\n                        HEAPU8[outIdx++] = 0xE0 | (u >> 12);\n                        HEAPU8[outIdx++] = 0x80 | ((u >> 6) & 63);\n                        HEAPU8[outIdx++] = 0x80 | (u & 63);\n                    }\n                    else {\n                        if (outIdx + 3 >= endIdx)\n                            break;\n                        HEAPU8[outIdx++] = 0xF0 | (u >> 18);\n                        HEAPU8[outIdx++] = 0x80 | ((u >> 12) & 63);\n                        HEAPU8[outIdx++] = 0x80 | ((u >> 6) & 63);\n                        HEAPU8[outIdx++] = 0x80 | (u & 63);\n                    }\n                }\n                HEAPU8[outIdx] = 0;\n                return outIdx - startIdx;\n            },\n            UTF16ToString: function (ptr, length) {\n                if (!ptr || !length)\n                    return '';\n                ptr >>>= 0;\n                var end = ptr;\n                if (length === -1) {\n                    var idx = end >> 1;\n                    var HEAPU16 = new Uint16Array(wasmMemory.buffer);\n                    while (HEAPU16[idx])\n                        ++idx;\n                    end = idx << 1;\n                }\n                else {\n                    end = ptr + (length >>> 0) * 2;\n                }\n                length = end - ptr;\n                if (length <= 32) {\n                    return String.fromCharCode.apply(null, new Uint16Array(wasmMemory.buffer, ptr, length / 2));\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var HEAPU8 = new Uint8Array(wasmMemory.buffer);\n                return emnapiString.utf16Decoder.decode(((typeof SharedArrayBuffer === \"function\" && HEAPU8.buffer instanceof SharedArrayBuffer) || (Object.prototype.toString.call(HEAPU8.buffer.constructor) === \"[object SharedArrayBuffer]\")) ? HEAPU8.slice(ptr, end) : HEAPU8.subarray(ptr, end));\n            },\n            stringToUTF16: function (str, outPtr, maxBytesToWrite) {\n                if (maxBytesToWrite === undefined) {\n                    maxBytesToWrite = 0x7FFFFFFF;\n                }\n                if (maxBytesToWrite < 2)\n                    return 0;\n                maxBytesToWrite -= 2;\n                var startPtr = outPtr;\n                var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                for (var i = 0; i < numCharsToWrite; ++i) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    var codeUnit = str.charCodeAt(i);\n                    HEAP_DATA_VIEW.setInt16(outPtr, codeUnit, true);\n                    outPtr += 2;\n                }\n                HEAP_DATA_VIEW.setInt16(outPtr, 0, true);\n                return outPtr - startPtr;\n            },\n            newString: function (env, str, length, result, stringMaker) {\n                if (!env)\n                    return 1 /* napi_status.napi_invalid_arg */;\n                // @ts-expect-error\n                var envObject = emnapiCtx.envStore.get(env);\n                envObject.checkGCAccess();\n                var autoLength = length === -1;\n                var sizelength = length >>> 0;\n                if (length !== 0) {\n                    if (!str)\n                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!(autoLength || (sizelength <= 2147483647)))\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var strValue = stringMaker(str, autoLength, sizelength);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var value = emnapiCtx.addToCurrentScope(strValue).id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.clearLastError();\n            },\n            newExternalString: function (env, str, length, finalize_callback, finalize_hint, result, copied, createApi, stringMaker) {\n                if (!env)\n                    return 1 /* napi_status.napi_invalid_arg */;\n                // @ts-expect-error\n                var envObject = emnapiCtx.envStore.get(env);\n                envObject.checkGCAccess();\n                var autoLength = length === -1;\n                var sizelength = length >>> 0;\n                if (length !== 0) {\n                    if (!str)\n                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!(autoLength || (sizelength <= 2147483647)))\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var status = createApi(env, str, length, result);\n                if (status === 0 /* napi_status.napi_ok */) {\n                    if (copied) {\n                        var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                        HEAP_DATA_VIEW.setInt8(copied, 1, true);\n                    }\n                    if (finalize_callback) {\n                        envObject.callFinalizer(finalize_callback, str, finalize_hint);\n                    }\n                }\n                return status;\n            }\n        };\n        /**\n         * @__sig ippp\n         */\n        function napi_get_array_length(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!value)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var handle = emnapiCtx.handleStore.get(value);\n                if (!handle.isArray()) {\n                    return envObject.setLastError(8 /* napi_status.napi_array_expected */);\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var v = handle.value.length >>> 0;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setUint32(result, v, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipppp\n         */\n        function napi_get_arraybuffer_info(env, arraybuffer, data, byte_length) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!arraybuffer)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(arraybuffer);\n            if (!handle.isArrayBuffer()) {\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            }\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if (data) {\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var p = emnapiExternalMemory.getArrayBufferPointer(handle.value, true).address;\n                HEAP_DATA_VIEW.setInt32(data, p, true);\n            }\n            if (byte_length) {\n                HEAP_DATA_VIEW.setUint32(byte_length, handle.value.byteLength, true);\n            }\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_get_prototype(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!value)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var handle = emnapiCtx.handleStore.get(value);\n                if (handle.value == null) {\n                    throw new TypeError('Cannot convert undefined or null to object');\n                }\n                var v = void 0;\n                try {\n                    v = handle.isObject() || handle.isFunction() ? handle.value : Object(handle.value);\n                }\n                catch (_) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var p = envObject.ensureHandleId(Object.getPrototypeOf(v));\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, p, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ippppppp\n         */\n        function napi_get_typedarray_info(env, typedarray, type, length, data, arraybuffer, byte_offset) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!typedarray)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(typedarray);\n            if (!handle.isTypedArray()) {\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            }\n            var v = handle.value;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if (type) {\n                var t = void 0;\n                if (v instanceof Int8Array) {\n                    t = 0 /* napi_typedarray_type.napi_int8_array */;\n                }\n                else if (v instanceof Uint8Array) {\n                    t = 1 /* napi_typedarray_type.napi_uint8_array */;\n                }\n                else if (v instanceof Uint8ClampedArray) {\n                    t = 2 /* napi_typedarray_type.napi_uint8_clamped_array */;\n                }\n                else if (v instanceof Int16Array) {\n                    t = 3 /* napi_typedarray_type.napi_int16_array */;\n                }\n                else if (v instanceof Uint16Array) {\n                    t = 4 /* napi_typedarray_type.napi_uint16_array */;\n                }\n                else if (v instanceof Int32Array) {\n                    t = 5 /* napi_typedarray_type.napi_int32_array */;\n                }\n                else if (v instanceof Uint32Array) {\n                    t = 6 /* napi_typedarray_type.napi_uint32_array */;\n                }\n                else if (v instanceof Float32Array) {\n                    t = 7 /* napi_typedarray_type.napi_float32_array */;\n                }\n                else if (v instanceof Float64Array) {\n                    t = 8 /* napi_typedarray_type.napi_float64_array */;\n                }\n                else if (v instanceof BigInt64Array) {\n                    t = 9 /* napi_typedarray_type.napi_bigint64_array */;\n                }\n                else if (v instanceof BigUint64Array) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    t = 10 /* napi_typedarray_type.napi_biguint64_array */;\n                }\n                else {\n                    return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n                }\n                HEAP_DATA_VIEW.setInt32(type, t, true);\n            }\n            if (length) {\n                HEAP_DATA_VIEW.setUint32(length, v.length, true);\n            }\n            var buffer;\n            if (data || arraybuffer) {\n                buffer = v.buffer;\n                if (data) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    var p = emnapiExternalMemory.getViewPointer(v, true).address;\n                    HEAP_DATA_VIEW.setInt32(data, p, true);\n                }\n                if (arraybuffer) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    var ab = envObject.ensureHandleId(buffer);\n                    HEAP_DATA_VIEW.setInt32(arraybuffer, ab, true);\n                }\n            }\n            if (byte_offset) {\n                HEAP_DATA_VIEW.setUint32(byte_offset, v.byteOffset, true);\n            }\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipppp\n         */\n        function napi_get_buffer_info(env, buffer, data, length) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!buffer)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(buffer);\n            if (!handle.isBuffer())\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            return napi_get_typedarray_info(env, buffer, 0, length, data, 0, 0);\n        }\n        /**\n         * @__sig ipppppp\n         */\n        function napi_get_dataview_info(env, dataview, byte_length, data, arraybuffer, byte_offset) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!dataview)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(dataview);\n            if (!handle.isDataView()) {\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            }\n            var v = handle.value;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if (byte_length) {\n                HEAP_DATA_VIEW.setUint32(byte_length, v.byteLength, true);\n            }\n            var buffer;\n            if (data || arraybuffer) {\n                buffer = v.buffer;\n                if (data) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    var p = emnapiExternalMemory.getViewPointer(v, true).address;\n                    HEAP_DATA_VIEW.setInt32(data, p, true);\n                }\n                if (arraybuffer) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    var ab = envObject.ensureHandleId(buffer);\n                    HEAP_DATA_VIEW.setInt32(arraybuffer, ab, true);\n                }\n            }\n            if (byte_offset) {\n                HEAP_DATA_VIEW.setUint32(byte_offset, v.byteOffset, true);\n            }\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_get_date_value(env, value, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!value)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var handle = emnapiCtx.handleStore.get(value);\n                if (!handle.isDate()) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                v = handle.value.valueOf();\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setFloat64(result, v, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_get_value_bool(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(value);\n            if (typeof handle.value !== 'boolean') {\n                return envObject.setLastError(7 /* napi_status.napi_boolean_expected */);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = handle.value ? 1 : 0;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt8(result, r, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_get_value_double(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(value);\n            if (typeof handle.value !== 'number') {\n                return envObject.setLastError(6 /* napi_status.napi_number_expected */);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = handle.value;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setFloat64(result, r, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipppp\n         */\n        function napi_get_value_bigint_int64(env, value, result, lossless) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!emnapiCtx.feature.supportBigInt) {\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!lossless)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(value);\n            var numberValue = handle.value;\n            if (typeof numberValue !== 'bigint') {\n                return envObject.setLastError(6 /* napi_status.napi_number_expected */);\n            }\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if ((numberValue >= (BigInt(-1) * (BigInt(1) << BigInt(63)))) && (numberValue < (BigInt(1) << BigInt(63)))) {\n                HEAP_DATA_VIEW.setInt8(lossless, 1, true);\n            }\n            else {\n                HEAP_DATA_VIEW.setInt8(lossless, 0, true);\n                numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1));\n                if (numberValue >= (BigInt(1) << BigInt(63))) {\n                    numberValue = numberValue - (BigInt(1) << BigInt(64));\n                }\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var low = Number(numberValue & BigInt(0xffffffff));\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var high = Number(numberValue >> BigInt(32));\n            HEAP_DATA_VIEW.setInt32(result, low, true);\n            HEAP_DATA_VIEW.setInt32(result + 4, high, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipppp\n         */\n        function napi_get_value_bigint_uint64(env, value, result, lossless) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!emnapiCtx.feature.supportBigInt) {\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!lossless)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(value);\n            var numberValue = handle.value;\n            if (typeof numberValue !== 'bigint') {\n                return envObject.setLastError(6 /* napi_status.napi_number_expected */);\n            }\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if ((numberValue >= BigInt(0)) && (numberValue < (BigInt(1) << BigInt(64)))) {\n                HEAP_DATA_VIEW.setInt8(lossless, 1, true);\n            }\n            else {\n                HEAP_DATA_VIEW.setInt8(lossless, 0, true);\n                numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1));\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var low = Number(numberValue & BigInt(0xffffffff));\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var high = Number(numberValue >> BigInt(32));\n            HEAP_DATA_VIEW.setUint32(result, low, true);\n            HEAP_DATA_VIEW.setUint32(result + 4, high, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippppp\n         */\n        function napi_get_value_bigint_words(env, value, sign_bit, word_count, words) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!emnapiCtx.feature.supportBigInt) {\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!word_count)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(value);\n            if (!handle.isBigInt()) {\n                return envObject.setLastError(17 /* napi_status.napi_bigint_expected */);\n            }\n            var isMinus = handle.value < BigInt(0);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            var word_count_int = HEAP_DATA_VIEW.getUint32(word_count, true);\n            var wordCount = 0;\n            var bigintValue = isMinus ? (handle.value * BigInt(-1)) : handle.value;\n            while (bigintValue !== BigInt(0)) {\n                wordCount++;\n                bigintValue = bigintValue >> BigInt(64);\n            }\n            bigintValue = isMinus ? (handle.value * BigInt(-1)) : handle.value;\n            if (!sign_bit && !words) {\n                word_count_int = wordCount;\n                HEAP_DATA_VIEW.setUint32(word_count, word_count_int, true);\n            }\n            else {\n                if (!sign_bit)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!words)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var wordsArr = [];\n                while (bigintValue !== BigInt(0)) {\n                    var uint64 = bigintValue & ((BigInt(1) << BigInt(64)) - BigInt(1));\n                    wordsArr.push(uint64);\n                    bigintValue = bigintValue >> BigInt(64);\n                }\n                var len = Math.min(word_count_int, wordsArr.length);\n                for (var i = 0; i < len; i++) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    var low = Number(wordsArr[i] & BigInt(0xffffffff));\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    var high = Number(wordsArr[i] >> BigInt(32));\n                    HEAP_DATA_VIEW.setUint32(words + i * 8, low, true);\n                    HEAP_DATA_VIEW.setUint32(words + i * 8 + 4, high, true);\n                }\n                HEAP_DATA_VIEW.setInt32(sign_bit, isMinus ? 1 : 0, true);\n                HEAP_DATA_VIEW.setUint32(word_count, len, true);\n            }\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_get_value_external(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(value);\n            if (!handle.isExternal()) {\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var p = handle.data(envObject);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, p, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_get_value_int32(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(value);\n            if (typeof handle.value !== 'number') {\n                return envObject.setLastError(6 /* napi_status.napi_number_expected */);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v = new Int32Array([handle.value])[0];\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, v, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_get_value_int64(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(value);\n            if (typeof handle.value !== 'number') {\n                return envObject.setLastError(6 /* napi_status.napi_number_expected */);\n            }\n            var numberValue = handle.value;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if (numberValue === Number.POSITIVE_INFINITY || numberValue === Number.NEGATIVE_INFINITY || isNaN(numberValue)) {\n                HEAP_DATA_VIEW.setInt32(result, 0, true);\n                HEAP_DATA_VIEW.setInt32(result + 4, 0, true);\n            }\n            else if (numberValue < /* INT64_RANGE_NEGATIVE */ -9223372036854776000) {\n                HEAP_DATA_VIEW.setInt32(result, 0, true);\n                HEAP_DATA_VIEW.setInt32(result + 4, 0x80000000, true);\n            }\n            else if (numberValue >= /* INT64_RANGE_POSITIVE */ 9223372036854776000) {\n                HEAP_DATA_VIEW.setUint32(result, 0xffffffff, true);\n                HEAP_DATA_VIEW.setUint32(result + 4, 0x7fffffff, true);\n            }\n            else {\n                $emnapiSetValueI64(result, Math.trunc(numberValue));\n            }\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippppp\n         */\n        function napi_get_value_string_latin1(env, value, buf, buf_size, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            buf_size = buf_size >>> 0;\n            var handle = emnapiCtx.handleStore.get(value);\n            if (typeof handle.value !== 'string') {\n                return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n            }\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if (!buf) {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                HEAP_DATA_VIEW.setUint32(result, handle.value.length, true);\n            }\n            else if (buf_size !== 0) {\n                var copied = 0;\n                var v = void 0;\n                for (var i = 0; i < buf_size - 1; ++i) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    v = handle.value.charCodeAt(i) & 0xff;\n                    HEAP_DATA_VIEW.setUint8(buf + i, v, true);\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    copied++;\n                }\n                HEAP_DATA_VIEW.setUint8(buf + copied, 0, true);\n                if (result) {\n                    HEAP_DATA_VIEW.setUint32(result, copied, true);\n                }\n            }\n            else if (result) {\n                HEAP_DATA_VIEW.setUint32(result, 0, true);\n            }\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippppp\n         */\n        function napi_get_value_string_utf8(env, value, buf, buf_size, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            buf_size = buf_size >>> 0;\n            var handle = emnapiCtx.handleStore.get(value);\n            if (typeof handle.value !== 'string') {\n                return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n            }\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if (!buf) {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var strLength = emnapiString.lengthBytesUTF8(handle.value);\n                HEAP_DATA_VIEW.setUint32(result, strLength, true);\n            }\n            else if (buf_size !== 0) {\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var copied = emnapiString.stringToUTF8(handle.value, buf, buf_size);\n                if (result) {\n                    HEAP_DATA_VIEW.setUint32(result, copied, true);\n                }\n            }\n            else if (result) {\n                HEAP_DATA_VIEW.setUint32(result, 0, true);\n            }\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippppp\n         */\n        function napi_get_value_string_utf16(env, value, buf, buf_size, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            buf_size = buf_size >>> 0;\n            var handle = emnapiCtx.handleStore.get(value);\n            if (typeof handle.value !== 'string') {\n                return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n            }\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if (!buf) {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                HEAP_DATA_VIEW.setUint32(result, handle.value.length, true);\n            }\n            else if (buf_size !== 0) {\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var copied = emnapiString.stringToUTF16(handle.value, buf, buf_size * 2);\n                if (result) {\n                    HEAP_DATA_VIEW.setUint32(result, copied / 2, true);\n                }\n            }\n            else if (result) {\n                HEAP_DATA_VIEW.setUint32(result, 0, true);\n            }\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_get_value_uint32(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(value);\n            if (typeof handle.value !== 'number') {\n                return envObject.setLastError(6 /* napi_status.napi_number_expected */);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v = new Uint32Array([handle.value])[0];\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setUint32(result, v, true);\n            return envObject.clearLastError();\n        }\n        var convert2cMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_get_array_length: napi_get_array_length,\n            napi_get_arraybuffer_info: napi_get_arraybuffer_info,\n            napi_get_buffer_info: napi_get_buffer_info,\n            napi_get_dataview_info: napi_get_dataview_info,\n            napi_get_date_value: napi_get_date_value,\n            napi_get_prototype: napi_get_prototype,\n            napi_get_typedarray_info: napi_get_typedarray_info,\n            napi_get_value_bigint_int64: napi_get_value_bigint_int64,\n            napi_get_value_bigint_uint64: napi_get_value_bigint_uint64,\n            napi_get_value_bigint_words: napi_get_value_bigint_words,\n            napi_get_value_bool: napi_get_value_bool,\n            napi_get_value_double: napi_get_value_double,\n            napi_get_value_external: napi_get_value_external,\n            napi_get_value_int32: napi_get_value_int32,\n            napi_get_value_int64: napi_get_value_int64,\n            napi_get_value_string_latin1: napi_get_value_string_latin1,\n            napi_get_value_string_utf16: napi_get_value_string_utf16,\n            napi_get_value_string_utf8: napi_get_value_string_utf8,\n            napi_get_value_uint32: napi_get_value_uint32\n        });\n        /**\n         * @__sig ipip\n         */\n        function napi_create_int32(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v = emnapiCtx.addToCurrentScope(value).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, v, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipip\n         */\n        function napi_create_uint32(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v = emnapiCtx.addToCurrentScope(value >>> 0).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, v, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipjp\n         */\n        function napi_create_int64(env, low, high, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            var value;\n            if (!high)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            value = Number(low);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v1 = emnapiCtx.addToCurrentScope(value).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(high, v1, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipdp\n         */\n        function napi_create_double(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v = emnapiCtx.addToCurrentScope(value).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, v, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipppp\n         */\n        function napi_create_string_latin1(env, str, length, result) {\n            return emnapiString.newString(env, str, length, result, function (str, autoLength, sizeLength) {\n                var latin1String = '';\n                var len = 0;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                if (autoLength) {\n                    while (true) {\n                        var ch = HEAP_DATA_VIEW.getUint8(str, true);\n                        if (!ch)\n                            break;\n                        latin1String += String.fromCharCode(ch);\n                        str++;\n                    }\n                }\n                else {\n                    while (len < sizeLength) {\n                        var ch = HEAP_DATA_VIEW.getUint8(str, true);\n                        if (!ch)\n                            break;\n                        latin1String += String.fromCharCode(ch);\n                        len++;\n                        str++;\n                    }\n                }\n                return latin1String;\n            });\n        }\n        /**\n         * @__sig ipppp\n         */\n        function napi_create_string_utf16(env, str, length, result) {\n            return emnapiString.newString(env, str, length, result, function (str) {\n                return emnapiString.UTF16ToString(str, length);\n            });\n        }\n        /**\n         * @__sig ipppp\n         */\n        function napi_create_string_utf8(env, str, length, result) {\n            return emnapiString.newString(env, str, length, result, function (str) {\n                return emnapiString.UTF8ToString(str, length);\n            });\n        }\n        /**\n         * @__sig ippppppp\n         */\n        function node_api_create_external_string_latin1(env, str, length, finalize_callback, finalize_hint, result, copied) {\n            return emnapiString.newExternalString(env, str, length, finalize_callback, finalize_hint, result, copied, napi_create_string_latin1, undefined);\n        }\n        /**\n         * @__sig ippppppp\n         */\n        function node_api_create_external_string_utf16(env, str, length, finalize_callback, finalize_hint, result, copied) {\n            return emnapiString.newExternalString(env, str, length, finalize_callback, finalize_hint, result, copied, napi_create_string_utf16, undefined);\n        }\n        /**\n         * @__sig ipppp\n         */\n        function node_api_create_property_key_utf16(env, str, length, result) {\n            return napi_create_string_utf16(env, str, length, result);\n        }\n        /**\n         * @__sig ipjp\n         */\n        function napi_create_bigint_int64(env, low, high, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!emnapiCtx.feature.supportBigInt) {\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            var value;\n            if (!high)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            value = low;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v1 = emnapiCtx.addToCurrentScope(value).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(high, v1, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipjp\n         */\n        function napi_create_bigint_uint64(env, low, high, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!emnapiCtx.feature.supportBigInt) {\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            var value;\n            if (!high)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            value = low & ((BigInt(1) << BigInt(64)) - BigInt(1));\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v1 = emnapiCtx.addToCurrentScope(value).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(high, v1, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipippp\n         */\n        function napi_create_bigint_words(env, sign_bit, word_count, words, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v, i;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!emnapiCtx.feature.supportBigInt) {\n                    return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n                }\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                word_count = word_count >>> 0;\n                if (word_count > 2147483647) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                if (word_count > (1024 * 1024 / (4 * 8) / 2)) {\n                    throw new RangeError('Maximum BigInt size exceeded');\n                }\n                var value = BigInt(0);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                for (i = 0; i < word_count; i++) {\n                    var low = HEAP_DATA_VIEW.getUint32(words + i * 8, true);\n                    var high = HEAP_DATA_VIEW.getUint32(words + i * 8 + 4, true);\n                    var wordi = BigInt(low) | (BigInt(high) << BigInt(32));\n                    value += wordi << BigInt(64 * i);\n                }\n                value *= ((BigInt(sign_bit) % BigInt(2) === BigInt(0)) ? BigInt(1) : BigInt(-1));\n                v = emnapiCtx.addToCurrentScope(value).id;\n                HEAP_DATA_VIEW.setInt32(result, v, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        var convert2napiMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_create_bigint_int64: napi_create_bigint_int64,\n            napi_create_bigint_uint64: napi_create_bigint_uint64,\n            napi_create_bigint_words: napi_create_bigint_words,\n            napi_create_double: napi_create_double,\n            napi_create_int32: napi_create_int32,\n            napi_create_int64: napi_create_int64,\n            napi_create_string_latin1: napi_create_string_latin1,\n            napi_create_string_utf16: napi_create_string_utf16,\n            napi_create_string_utf8: napi_create_string_utf8,\n            napi_create_uint32: napi_create_uint32,\n            node_api_create_external_string_latin1: node_api_create_external_string_latin1,\n            node_api_create_external_string_utf16: node_api_create_external_string_utf16,\n            node_api_create_property_key_utf16: node_api_create_property_key_utf16\n        });\n        function emnapiCreateFunction(envObject, utf8name, length, cb, data) {\n            var functionName = (!utf8name || !length) ? '' : (emnapiString.UTF8ToString(utf8name, length));\n            var f;\n            var makeFunction = function () {\n                return function () {\n                    var cbinfo = emnapiCtx.cbinfoStack.push(this, data, arguments, f);\n                    var scope = emnapiCtx.openScope(envObject);\n                    try {\n                        return envObject.callIntoModule(function (envObject) {\n                            var napiValue = (wasmTable.get(cb))(envObject.id, cbinfo);\n                            return (!napiValue) ? undefined : emnapiCtx.handleStore.get(napiValue).value;\n                        });\n                    }\n                    finally {\n                        emnapiCtx.cbinfoStack.pop();\n                        emnapiCtx.closeScope(envObject, scope);\n                    }\n                };\n            };\n            if (functionName === '') {\n                f = makeFunction();\n                return { status: 0 /* napi_status.napi_ok */, f: f };\n            }\n            if (!(/^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(functionName))) {\n                return { status: 1 /* napi_status.napi_invalid_arg */, f: undefined };\n            }\n            if (emnapiCtx.feature.supportNewFunction) {\n                var _ = makeFunction();\n                try {\n                    f = (new Function('_', 'return function ' + functionName + '(){' +\n                        '\"use strict\";' +\n                        'return _.apply(this,arguments);' +\n                        '};'))(_);\n                }\n                catch (_err) {\n                    f = makeFunction();\n                    if (emnapiCtx.feature.canSetFunctionName)\n                        Object.defineProperty(f, 'name', { value: functionName });\n                }\n            }\n            else {\n                f = makeFunction();\n                if (emnapiCtx.feature.canSetFunctionName)\n                    Object.defineProperty(f, 'name', { value: functionName });\n            }\n            return { status: 0 /* napi_status.napi_ok */, f: f };\n        }\n        function emnapiDefineProperty(envObject, obj, propertyName, method, getter, setter, value, attributes, data) {\n            if (getter || setter) {\n                var localGetter = void 0;\n                var localSetter = void 0;\n                if (getter) {\n                    localGetter = emnapiCreateFunction(envObject, 0, 0, getter, data).f;\n                }\n                if (setter) {\n                    localSetter = emnapiCreateFunction(envObject, 0, 0, setter, data).f;\n                }\n                var desc = {\n                    configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0,\n                    enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0,\n                    get: localGetter,\n                    set: localSetter\n                };\n                Object.defineProperty(obj, propertyName, desc);\n            }\n            else if (method) {\n                var localMethod = emnapiCreateFunction(envObject, 0, 0, method, data).f;\n                var desc = {\n                    configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0,\n                    enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0,\n                    writable: (attributes & 1 /* napi_property_attributes.napi_writable */) !== 0,\n                    value: localMethod\n                };\n                Object.defineProperty(obj, propertyName, desc);\n            }\n            else {\n                var desc = {\n                    configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0,\n                    enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0,\n                    writable: (attributes & 1 /* napi_property_attributes.napi_writable */) !== 0,\n                    value: emnapiCtx.handleStore.get(value).value\n                };\n                Object.defineProperty(obj, propertyName, desc);\n            }\n        }\n        function emnapiGetHandle(js_object) {\n            var handle = emnapiCtx.handleStore.get(js_object);\n            if (!(handle.isObject() || handle.isFunction())) {\n                return { status: 1 /* napi_status.napi_invalid_arg */ };\n            }\n            if (typeof emnapiExternalMemory !== 'undefined' && ArrayBuffer.isView(handle.value)) {\n                if (emnapiExternalMemory.wasmMemoryViewTable.has(handle.value)) {\n                    handle = emnapiCtx.addToCurrentScope(emnapiExternalMemory.wasmMemoryViewTable.get(handle.value));\n                }\n            }\n            return { status: 0 /* napi_status.napi_ok */, handle: handle };\n        }\n        function emnapiWrap(env, js_object, native_object, finalize_cb, finalize_hint, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var referenceId;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!emnapiCtx.feature.supportFinalizer) {\n                    if (finalize_cb) {\n                        throw emnapiCtx.createNotSupportWeakRefError('napi_wrap', 'Parameter \"finalize_cb\" must be 0(NULL)');\n                    }\n                    if (result) {\n                        throw emnapiCtx.createNotSupportWeakRefError('napi_wrap', 'Parameter \"result\" must be 0(NULL)');\n                    }\n                }\n                if (!js_object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var handleResult = emnapiGetHandle(js_object);\n                if (handleResult.status !== 0 /* napi_status.napi_ok */) {\n                    return envObject.setLastError(handleResult.status);\n                }\n                var handle = handleResult.handle;\n                if (envObject.getObjectBinding(handle.value).wrapped !== 0) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var reference = void 0;\n                if (result) {\n                    if (!finalize_cb)\n                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                    reference = emnapiCtx.createReference(envObject, handle.id, 0, 1 /* Ownership.kUserland */, finalize_cb, native_object, finalize_hint);\n                    referenceId = reference.id;\n                    var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                    HEAP_DATA_VIEW.setInt32(result, referenceId, true);\n                }\n                else {\n                    reference = emnapiCtx.createReference(envObject, handle.id, 0, 0 /* Ownership.kRuntime */, finalize_cb, native_object, !finalize_cb ? finalize_cb : finalize_hint);\n                }\n                envObject.getObjectBinding(handle.value).wrapped = reference.id;\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        function emnapiUnwrap(env, js_object, result, action) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var data;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!js_object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (action === 0 /* UnwrapAction.KeepWrap */) {\n                    if (!result)\n                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var value = emnapiCtx.handleStore.get(js_object);\n                if (!(value.isObject() || value.isFunction())) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var binding = envObject.getObjectBinding(value.value);\n                var referenceId = binding.wrapped;\n                var ref = emnapiCtx.refStore.get(referenceId);\n                if (!ref)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (result) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    data = ref.data();\n                    var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                    HEAP_DATA_VIEW.setInt32(result, data, true);\n                }\n                if (action === 1 /* UnwrapAction.RemoveWrap */) {\n                    binding.wrapped = 0;\n                    if (ref.ownership() === 1 /* Ownership.kUserland */) {\n                        // When the wrap is been removed, the finalizer should be reset.\n                        ref.resetFinalizer();\n                    }\n                    else {\n                        ref.dispose();\n                    }\n                }\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipppppppp\n         */\n        function napi_define_class(env, utf8name, length, constructor, callback_data, property_count, properties, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var propPtr, valueHandleId, attributes;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!constructor)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                property_count = property_count >>> 0;\n                if (property_count > 0) {\n                    if (!properties)\n                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                if ((length < -1) || (length > 2147483647) || (!utf8name)) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var fresult = emnapiCreateFunction(envObject, utf8name, length, constructor, callback_data);\n                if (fresult.status !== 0 /* napi_status.napi_ok */)\n                    return envObject.setLastError(fresult.status);\n                var F = fresult.f;\n                var propertyName = void 0;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                for (var i = 0; i < property_count; i++) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    propPtr = properties + (i * (4 * 8));\n                    var utf8Name = HEAP_DATA_VIEW.getInt32(propPtr, true);\n                    var name_1 = HEAP_DATA_VIEW.getInt32(propPtr + 4, true);\n                    var method = HEAP_DATA_VIEW.getInt32(propPtr + 8, true);\n                    var getter = HEAP_DATA_VIEW.getInt32(propPtr + 12, true);\n                    var setter = HEAP_DATA_VIEW.getInt32(propPtr + 16, true);\n                    var value = HEAP_DATA_VIEW.getInt32(propPtr + 20, true);\n                    attributes = HEAP_DATA_VIEW.getInt32(propPtr + 24, true);\n                    var data = HEAP_DATA_VIEW.getInt32(propPtr + 28, true);\n                    if (utf8Name) {\n                        propertyName = emnapiString.UTF8ToString(utf8Name, -1);\n                    }\n                    else {\n                        if (!name_1) {\n                            return envObject.setLastError(4 /* napi_status.napi_name_expected */);\n                        }\n                        propertyName = emnapiCtx.handleStore.get(name_1).value;\n                        if (typeof propertyName !== 'string' && typeof propertyName !== 'symbol') {\n                            return envObject.setLastError(4 /* napi_status.napi_name_expected */);\n                        }\n                    }\n                    if ((attributes & 1024 /* napi_property_attributes.napi_static */) !== 0) {\n                        emnapiDefineProperty(envObject, F, propertyName, method, getter, setter, value, attributes, data);\n                        continue;\n                    }\n                    emnapiDefineProperty(envObject, F.prototype, propertyName, method, getter, setter, value, attributes, data);\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var valueHandle = emnapiCtx.addToCurrentScope(F);\n                valueHandleId = valueHandle.id;\n                HEAP_DATA_VIEW.setInt32(result, valueHandleId, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipppppp\n         */\n        function napi_wrap(env, js_object, native_object, finalize_cb, finalize_hint, result) {\n            return emnapiWrap(env, js_object, native_object, finalize_cb, finalize_hint, result);\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_unwrap(env, js_object, result) {\n            return emnapiUnwrap(env, js_object, result, 0 /* UnwrapAction.KeepWrap */);\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_remove_wrap(env, js_object, result) {\n            return emnapiUnwrap(env, js_object, result, 1 /* UnwrapAction.RemoveWrap */);\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_type_tag_object(env, object, type_tag) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!object) {\n                    return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);\n                }\n                var value = emnapiCtx.handleStore.get(object);\n                if (!(value.isObject() || value.isFunction())) {\n                    return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */);\n                }\n                if (!type_tag) {\n                    return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);\n                }\n                var binding = envObject.getObjectBinding(value.value);\n                if (binding.tag !== null) {\n                    return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);\n                }\n                var tag = new Uint8Array(16);\n                tag.set(new Uint8Array(wasmMemory.buffer, type_tag, 16));\n                binding.tag = new Uint32Array(tag.buffer);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipppp\n         */\n        function napi_check_object_type_tag(env, object, type_tag, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars, one-var\n            var ret = true;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!object) {\n                    return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);\n                }\n                var value = emnapiCtx.handleStore.get(object);\n                if (!(value.isObject() || value.isFunction())) {\n                    return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */);\n                }\n                if (!type_tag) {\n                    return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);\n                }\n                if (!result) {\n                    return envObject.setLastError(envObject.tryCatch.hasCaught() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */);\n                }\n                var binding = envObject.getObjectBinding(value.value);\n                if (binding.tag !== null) {\n                    var tag = binding.tag;\n                    var typeTag = new Uint32Array(wasmMemory.buffer, type_tag, 4);\n                    ret = (tag[0] === typeTag[0] &&\n                        tag[1] === typeTag[1] &&\n                        tag[2] === typeTag[2] &&\n                        tag[3] === typeTag[3]);\n                }\n                else {\n                    ret = false;\n                }\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt8(result, ret ? 1 : 0, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipppppp\n         */\n        function napi_add_finalizer(env, js_object, finalize_data, finalize_cb, finalize_hint, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!emnapiCtx.feature.supportFinalizer) {\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            if (!js_object)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!finalize_cb)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handleResult = emnapiGetHandle(js_object);\n            if (handleResult.status !== 0 /* napi_status.napi_ok */) {\n                return envObject.setLastError(handleResult.status);\n            }\n            var handle = handleResult.handle;\n            var ownership = !result ? 0 /* Ownership.kRuntime */ : 1 /* Ownership.kUserland */;\n            var reference = emnapiCtx.createReference(envObject, handle.id, 0, ownership, finalize_cb, finalize_data, finalize_hint);\n            if (result) {\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var referenceId = reference.id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, referenceId, true);\n            }\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipppp\n         */\n        function node_api_post_finalizer(env, finalize_cb, finalize_data, finalize_hint) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.enqueueFinalizer(emnapiCtx.createTrackedFinalizer(envObject, finalize_cb, finalize_data, finalize_hint));\n            return envObject.clearLastError();\n        }\n        var wrapMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_add_finalizer: napi_add_finalizer,\n            napi_check_object_type_tag: napi_check_object_type_tag,\n            napi_define_class: napi_define_class,\n            napi_remove_wrap: napi_remove_wrap,\n            napi_type_tag_object: napi_type_tag_object,\n            napi_unwrap: napi_unwrap,\n            napi_wrap: napi_wrap,\n            node_api_post_finalizer: node_api_post_finalizer\n        });\n        /**\n         * @__sig ipippppp\n         */\n        function emnapi_create_memory_view(env, typedarray_type, external_data, byte_length, finalize_cb, finalize_hint, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                byte_length = byte_length >>> 0;\n                if (!external_data) {\n                    byte_length = 0;\n                }\n                if (byte_length > 2147483647) {\n                    throw new RangeError('Cannot create a memory view larger than 2147483647 bytes');\n                }\n                if ((external_data + byte_length) > wasmMemory.buffer.byteLength) {\n                    throw new RangeError('Memory out of range');\n                }\n                if (!emnapiCtx.feature.supportFinalizer && finalize_cb) {\n                    throw emnapiCtx.createNotSupportWeakRefError('emnapi_create_memory_view', 'Parameter \"finalize_cb\" must be 0(NULL)');\n                }\n                var viewDescriptor = void 0;\n                switch (typedarray_type) {\n                    case 0 /* emnapi_memory_view_type.emnapi_int8_array */:\n                        viewDescriptor = { Ctor: Int8Array, address: external_data, length: byte_length, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case 1 /* emnapi_memory_view_type.emnapi_uint8_array */:\n                        viewDescriptor = { Ctor: Uint8Array, address: external_data, length: byte_length, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case 2 /* emnapi_memory_view_type.emnapi_uint8_clamped_array */:\n                        viewDescriptor = { Ctor: Uint8ClampedArray, address: external_data, length: byte_length, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case 3 /* emnapi_memory_view_type.emnapi_int16_array */:\n                        viewDescriptor = { Ctor: Int16Array, address: external_data, length: byte_length >> 1, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case 4 /* emnapi_memory_view_type.emnapi_uint16_array */:\n                        viewDescriptor = { Ctor: Uint16Array, address: external_data, length: byte_length >> 1, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case 5 /* emnapi_memory_view_type.emnapi_int32_array */:\n                        viewDescriptor = { Ctor: Int32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case 6 /* emnapi_memory_view_type.emnapi_uint32_array */:\n                        viewDescriptor = { Ctor: Uint32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case 7 /* emnapi_memory_view_type.emnapi_float32_array */:\n                        viewDescriptor = { Ctor: Float32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case 8 /* emnapi_memory_view_type.emnapi_float64_array */:\n                        viewDescriptor = { Ctor: Float64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case 9 /* emnapi_memory_view_type.emnapi_bigint64_array */:\n                        viewDescriptor = { Ctor: BigInt64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case 10 /* emnapi_memory_view_type.emnapi_biguint64_array */:\n                        viewDescriptor = { Ctor: BigUint64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case -1 /* emnapi_memory_view_type.emnapi_data_view */:\n                        viewDescriptor = { Ctor: DataView, address: external_data, length: byte_length, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    case -2 /* emnapi_memory_view_type.emnapi_buffer */: {\n                        if (!emnapiCtx.feature.Buffer) {\n                            throw emnapiCtx.createNotSupportBufferError('emnapi_create_memory_view', '');\n                        }\n                        viewDescriptor = { Ctor: emnapiCtx.feature.Buffer, address: external_data, length: byte_length, ownership: 1 /* Ownership.kUserland */, runtimeAllocated: 0 };\n                        break;\n                    }\n                    default: return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var Ctor = viewDescriptor.Ctor;\n                var typedArray = typedarray_type === -2 /* emnapi_memory_view_type.emnapi_buffer */\n                    ? emnapiCtx.feature.Buffer.from(wasmMemory.buffer, viewDescriptor.address, viewDescriptor.length)\n                    : new Ctor(wasmMemory.buffer, viewDescriptor.address, viewDescriptor.length);\n                var handle = emnapiCtx.addToCurrentScope(typedArray);\n                emnapiExternalMemory.wasmMemoryViewTable.set(typedArray, viewDescriptor);\n                if (finalize_cb) {\n                    var status_1 = napi_add_finalizer(env, handle.id, external_data, finalize_cb, finalize_hint, /* NULL */ 0);\n                    if (status_1 === 10 /* napi_status.napi_pending_exception */) {\n                        var err = envObject.tryCatch.extractException();\n                        envObject.clearLastError();\n                        throw err;\n                    }\n                    else if (status_1 !== 0 /* napi_status.napi_ok */) {\n                        return envObject.setLastError(status_1);\n                    }\n                }\n                value = handle.id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig i\n         */\n        function emnapi_is_support_weakref() {\n            return emnapiCtx.feature.supportFinalizer ? 1 : 0;\n        }\n        /**\n         * @__sig i\n         */\n        function emnapi_is_support_bigint() {\n            return emnapiCtx.feature.supportBigInt ? 1 : 0;\n        }\n        /**\n         * @__sig i\n         */\n        function emnapi_is_node_binding_available() {\n            return emnapiNodeBinding ? 1 : 0;\n        }\n        function $emnapiSyncMemory(js_to_wasm, arrayBufferOrView, offset, len) {\n            offset = offset !== null && offset !== void 0 ? offset : 0;\n            offset = offset >>> 0;\n            var view;\n            if (arrayBufferOrView instanceof ArrayBuffer) {\n                var pointer = emnapiExternalMemory.getArrayBufferPointer(arrayBufferOrView, false).address;\n                if (!pointer)\n                    throw new Error('Unknown ArrayBuffer address');\n                if (typeof len !== 'number' || len === -1) {\n                    len = arrayBufferOrView.byteLength - offset;\n                }\n                len = len >>> 0;\n                if (len === 0)\n                    return arrayBufferOrView;\n                view = new Uint8Array(arrayBufferOrView, offset, len);\n                var wasmMemoryU8 = new Uint8Array(wasmMemory.buffer);\n                if (!js_to_wasm) {\n                    view.set(wasmMemoryU8.subarray(pointer, pointer + len));\n                }\n                else {\n                    wasmMemoryU8.set(view, pointer);\n                }\n                return arrayBufferOrView;\n            }\n            if (ArrayBuffer.isView(arrayBufferOrView)) {\n                var viewPointerInfo = emnapiExternalMemory.getViewPointer(arrayBufferOrView, false);\n                var latestView = viewPointerInfo.view;\n                var pointer = viewPointerInfo.address;\n                if (!pointer)\n                    throw new Error('Unknown ArrayBuffer address');\n                if (typeof len !== 'number' || len === -1) {\n                    len = latestView.byteLength - offset;\n                }\n                len = len >>> 0;\n                if (len === 0)\n                    return latestView;\n                view = new Uint8Array(latestView.buffer, latestView.byteOffset + offset, len);\n                var wasmMemoryU8 = new Uint8Array(wasmMemory.buffer);\n                if (!js_to_wasm) {\n                    view.set(wasmMemoryU8.subarray(pointer, pointer + len));\n                }\n                else {\n                    wasmMemoryU8.set(view, pointer);\n                }\n                return latestView;\n            }\n            throw new TypeError('emnapiSyncMemory expect ArrayBuffer or ArrayBufferView as first parameter');\n        }\n        /**\n         * @__sig ipippp\n         */\n        function emnapi_sync_memory(env, js_to_wasm, arraybuffer_or_view, offset, len) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!arraybuffer_or_view)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                var handleId = HEAP_DATA_VIEW.getInt32(arraybuffer_or_view, true);\n                var handle = envObject.ctx.handleStore.get(handleId);\n                if (!handle.isArrayBuffer() && !handle.isTypedArray() && !handle.isDataView()) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var ret = $emnapiSyncMemory(Boolean(js_to_wasm), handle.value, offset, len);\n                if (handle.value !== ret) {\n                    v = envObject.ensureHandleId(ret);\n                    HEAP_DATA_VIEW.setInt32(arraybuffer_or_view, v, true);\n                }\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        function $emnapiGetMemoryAddress(arrayBufferOrView) {\n            var isArrayBuffer = arrayBufferOrView instanceof ArrayBuffer;\n            var isDataView = arrayBufferOrView instanceof DataView;\n            var isTypedArray = ArrayBuffer.isView(arrayBufferOrView) && !isDataView;\n            if (!isArrayBuffer && !isTypedArray && !isDataView) {\n                throw new TypeError('emnapiGetMemoryAddress expect ArrayBuffer or ArrayBufferView as first parameter');\n            }\n            var info;\n            if (isArrayBuffer) {\n                info = emnapiExternalMemory.getArrayBufferPointer(arrayBufferOrView, false);\n            }\n            else {\n                info = emnapiExternalMemory.getViewPointer(arrayBufferOrView, false);\n            }\n            return {\n                address: info.address,\n                ownership: info.ownership,\n                runtimeAllocated: info.runtimeAllocated\n            };\n        }\n        /**\n         * @__sig ipppp\n         */\n        function emnapi_get_memory_address(env, arraybuffer_or_view, address, ownership, runtime_allocated) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var p, runtimeAllocated, ownershipOut;\n            var info;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!arraybuffer_or_view)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!address && !ownership && !runtime_allocated) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var handle = envObject.ctx.handleStore.get(arraybuffer_or_view);\n                info = $emnapiGetMemoryAddress(handle.value);\n                p = info.address;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                if (address) {\n                    HEAP_DATA_VIEW.setInt32(address, p, true);\n                }\n                if (ownership) {\n                    ownershipOut = info.ownership;\n                    HEAP_DATA_VIEW.setInt32(ownership, ownershipOut, true);\n                }\n                if (runtime_allocated) {\n                    runtimeAllocated = info.runtimeAllocated;\n                    HEAP_DATA_VIEW.setInt8(runtime_allocated, runtimeAllocated, true);\n                }\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipp\n         */\n        function emnapi_get_runtime_version(env, version) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            var envObject = emnapiCtx.envStore.get(env);\n            if (!version)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var runtimeVersion;\n            try {\n                runtimeVersion = emnapiCtx.getRuntimeVersions().version;\n            }\n            catch (_) {\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var versions = runtimeVersion.split('.')\n                .map(function (n) { return Number(n); });\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setUint32(version, versions[0], true);\n            HEAP_DATA_VIEW.setUint32(version + 4, versions[1], true);\n            HEAP_DATA_VIEW.setUint32(version + 8, versions[2], true);\n            return envObject.clearLastError();\n        }\n        var emnapiMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            $emnapiGetMemoryAddress: $emnapiGetMemoryAddress,\n            $emnapiSyncMemory: $emnapiSyncMemory,\n            emnapi_create_memory_view: emnapi_create_memory_view,\n            emnapi_get_memory_address: emnapi_get_memory_address,\n            emnapi_get_runtime_version: emnapi_get_runtime_version,\n            emnapi_is_node_binding_available: emnapi_is_node_binding_available,\n            emnapi_is_support_bigint: emnapi_is_support_bigint,\n            emnapi_is_support_weakref: emnapi_is_support_weakref,\n            emnapi_sync_memory: emnapi_sync_memory\n        });\n        /**\n         * @__sig ipp\n         */\n        function napi_create_array(env, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = emnapiCtx.addToCurrentScope([]).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_create_array_with_length(env, length, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            length = length >>> 0;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = emnapiCtx.addToCurrentScope(new Array(length)).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        function emnapiCreateArrayBuffer(byte_length, data) {\n            byte_length = byte_length >>> 0;\n            var arrayBuffer = new ArrayBuffer(byte_length);\n            if (data) {\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var p = emnapiExternalMemory.getArrayBufferPointer(arrayBuffer, true).address;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(data, p, true);\n            }\n            return arrayBuffer;\n        }\n        /**\n         * @__sig ipppp\n         */\n        function napi_create_arraybuffer(env, byte_length, data, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var arrayBuffer = emnapiCreateArrayBuffer(byte_length, data);\n                value = emnapiCtx.addToCurrentScope(arrayBuffer).id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipdp\n         */\n        function napi_create_date(env, time, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                value = emnapiCtx.addToCurrentScope(new Date(time)).id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ippppp\n         */\n        function napi_create_external(env, data, finalize_cb, finalize_hint, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!emnapiCtx.feature.supportFinalizer && finalize_cb) {\n                    throw emnapiCtx.createNotSupportWeakRefError('napi_create_external', 'Parameter \"finalize_cb\" must be 0(NULL)');\n                }\n                var externalHandle = emnapiCtx.getCurrentScope().addExternal(envObject, data);\n                if (finalize_cb) {\n                    emnapiCtx.createReference(envObject, externalHandle.id, 0, 0 /* Ownership.kRuntime */, finalize_cb, data, finalize_hint);\n                }\n                value = externalHandle.id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.clearLastError();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipppppp\n         */\n        function napi_create_external_arraybuffer(env, external_data, byte_length, finalize_cb, finalize_hint, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                byte_length = byte_length >>> 0;\n                if (!external_data) {\n                    byte_length = 0;\n                }\n                if ((external_data + byte_length) > wasmMemory.buffer.byteLength) {\n                    throw new RangeError('Memory out of range');\n                }\n                if (!emnapiCtx.feature.supportFinalizer && finalize_cb) {\n                    throw emnapiCtx.createNotSupportWeakRefError('napi_create_external_arraybuffer', 'Parameter \"finalize_cb\" must be 0(NULL)');\n                }\n                var arrayBuffer = new ArrayBuffer(byte_length);\n                if (byte_length === 0) {\n                    try {\n                        var MessageChannel_1 = emnapiCtx.feature.MessageChannel;\n                        var messageChannel = new MessageChannel_1();\n                        messageChannel.port1.postMessage(arrayBuffer, [arrayBuffer]);\n                    }\n                    catch (_) { }\n                }\n                else {\n                    var u8arr = new Uint8Array(arrayBuffer);\n                    u8arr.set(new Uint8Array(wasmMemory.buffer).subarray(external_data, external_data + byte_length));\n                    emnapiExternalMemory.table.set(arrayBuffer, {\n                        address: external_data,\n                        ownership: 1 /* Ownership.kUserland */,\n                        runtimeAllocated: 0\n                    });\n                }\n                var handle = emnapiCtx.addToCurrentScope(arrayBuffer);\n                if (finalize_cb) {\n                    var status_1 = napi_add_finalizer(env, handle.id, external_data, finalize_cb, finalize_hint, /* NULL */ 0);\n                    if (status_1 === 10 /* napi_status.napi_pending_exception */) {\n                        var err = envObject.tryCatch.extractException();\n                        envObject.clearLastError();\n                        throw err;\n                    }\n                    else if (status_1 !== 0 /* napi_status.napi_ok */) {\n                        return envObject.setLastError(status_1);\n                    }\n                }\n                value = handle.id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipp\n         */\n        function napi_create_object(env, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = emnapiCtx.addToCurrentScope({}).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ippp\n         */\n        function napi_create_symbol(env, description, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if (!description) {\n                // eslint-disable-next-line symbol-description, @typescript-eslint/no-unused-vars\n                var value = emnapiCtx.addToCurrentScope(Symbol()).id;\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n            }\n            else {\n                var handle = emnapiCtx.handleStore.get(description);\n                var desc = handle.value;\n                if (typeof desc !== 'string') {\n                    return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var v = emnapiCtx.addToCurrentScope(Symbol(desc)).id;\n                HEAP_DATA_VIEW.setInt32(result, v, true);\n            }\n            return envObject.clearLastError();\n        }\n        /**\n         * @__sig ipipppp\n         */\n        function napi_create_typedarray(env, type, length, arraybuffer, byte_offset, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!arraybuffer)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var handle = emnapiCtx.handleStore.get(arraybuffer);\n                var buffer = handle.value;\n                if (!(buffer instanceof ArrayBuffer)) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var createTypedArray = function (envObject, Type, size_of_element, buffer, byte_offset, length) {\n                    var _a;\n                    byte_offset = byte_offset >>> 0;\n                    length = length >>> 0;\n                    if (size_of_element > 1) {\n                        if ((byte_offset) % (size_of_element) !== 0) {\n                            var err = new RangeError(\"start offset of \".concat((_a = Type.name) !== null && _a !== void 0 ? _a : '', \" should be a multiple of \").concat(size_of_element));\n                            err.code = 'ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT';\n                            envObject.tryCatch.setError(err);\n                            return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n                        }\n                    }\n                    if (((length * size_of_element) + byte_offset) > buffer.byteLength) {\n                        var err = new RangeError('Invalid typed array length');\n                        err.code = 'ERR_NAPI_INVALID_TYPEDARRAY_LENGTH';\n                        envObject.tryCatch.setError(err);\n                        return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n                    }\n                    var out = new Type(buffer, byte_offset, length);\n                    if (buffer === wasmMemory.buffer) {\n                        if (!emnapiExternalMemory.wasmMemoryViewTable.has(out)) {\n                            emnapiExternalMemory.wasmMemoryViewTable.set(out, {\n                                Ctor: Type,\n                                address: byte_offset,\n                                length: length,\n                                ownership: 1 /* Ownership.kUserland */,\n                                runtimeAllocated: 0\n                            });\n                        }\n                    }\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    value = emnapiCtx.addToCurrentScope(out).id;\n                    var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                    HEAP_DATA_VIEW.setInt32(result, value, true);\n                    return envObject.getReturnStatus();\n                };\n                switch (type) {\n                    case 0 /* napi_typedarray_type.napi_int8_array */:\n                        return createTypedArray(envObject, Int8Array, 1, buffer, byte_offset, length);\n                    case 1 /* napi_typedarray_type.napi_uint8_array */:\n                        return createTypedArray(envObject, Uint8Array, 1, buffer, byte_offset, length);\n                    case 2 /* napi_typedarray_type.napi_uint8_clamped_array */:\n                        return createTypedArray(envObject, Uint8ClampedArray, 1, buffer, byte_offset, length);\n                    case 3 /* napi_typedarray_type.napi_int16_array */:\n                        return createTypedArray(envObject, Int16Array, 2, buffer, byte_offset, length);\n                    case 4 /* napi_typedarray_type.napi_uint16_array */:\n                        return createTypedArray(envObject, Uint16Array, 2, buffer, byte_offset, length);\n                    case 5 /* napi_typedarray_type.napi_int32_array */:\n                        return createTypedArray(envObject, Int32Array, 4, buffer, byte_offset, length);\n                    case 6 /* napi_typedarray_type.napi_uint32_array */:\n                        return createTypedArray(envObject, Uint32Array, 4, buffer, byte_offset, length);\n                    case 7 /* napi_typedarray_type.napi_float32_array */:\n                        return createTypedArray(envObject, Float32Array, 4, buffer, byte_offset, length);\n                    case 8 /* napi_typedarray_type.napi_float64_array */:\n                        return createTypedArray(envObject, Float64Array, 8, buffer, byte_offset, length);\n                    case 9 /* napi_typedarray_type.napi_bigint64_array */:\n                        return createTypedArray(envObject, BigInt64Array, 8, buffer, byte_offset, length);\n                    case 10 /* napi_typedarray_type.napi_biguint64_array */:\n                        return createTypedArray(envObject, BigUint64Array, 8, buffer, byte_offset, length);\n                    default:\n                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__deps malloc\n         * @__sig ippp\n         */\n        function napi_create_buffer(env, size, data, result) {\n            var _a;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value, pointer;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var Buffer = emnapiCtx.feature.Buffer;\n                if (!Buffer) {\n                    throw emnapiCtx.createNotSupportBufferError('napi_create_buffer', '');\n                }\n                var buffer = void 0;\n                size = size >>> 0;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                if (!data || (size === 0)) {\n                    buffer = Buffer.alloc(size);\n                    value = emnapiCtx.addToCurrentScope(buffer).id;\n                    HEAP_DATA_VIEW.setInt32(result, value, true);\n                }\n                else {\n                    pointer = _malloc(size);\n                    if (!pointer)\n                        throw new Error('Out of memory');\n                    new Uint8Array(wasmMemory.buffer).subarray(pointer, pointer + size).fill(0);\n                    var buffer_1 = Buffer.from(wasmMemory.buffer, pointer, size);\n                    var viewDescriptor = {\n                        Ctor: Buffer,\n                        address: pointer,\n                        length: size,\n                        ownership: emnapiExternalMemory.registry ? 0 /* Ownership.kRuntime */ : 1 /* Ownership.kUserland */,\n                        runtimeAllocated: 1\n                    };\n                    emnapiExternalMemory.wasmMemoryViewTable.set(buffer_1, viewDescriptor);\n                    (_a = emnapiExternalMemory.registry) === null || _a === void 0 ? void 0 : _a.register(viewDescriptor, pointer);\n                    value = emnapiCtx.addToCurrentScope(buffer_1).id;\n                    HEAP_DATA_VIEW.setInt32(result, value, true);\n                    HEAP_DATA_VIEW.setInt32(data, pointer, true);\n                }\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ippppp\n         */\n        function napi_create_buffer_copy(env, length, data, result_data, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var Buffer = emnapiCtx.feature.Buffer;\n                if (!Buffer) {\n                    throw emnapiCtx.createNotSupportBufferError('napi_create_buffer_copy', '');\n                }\n                var arrayBuffer = emnapiCreateArrayBuffer(length, result_data);\n                var buffer = Buffer.from(arrayBuffer);\n                buffer.set(new Uint8Array(wasmMemory.buffer).subarray(data, data + length));\n                value = emnapiCtx.addToCurrentScope(buffer).id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipppppp\n         */\n        function napi_create_external_buffer(env, length, data, finalize_cb, finalize_hint, result) {\n            return emnapi_create_memory_view(env, -2 /* emnapi_memory_view_type.emnapi_buffer */, data, length, finalize_cb, finalize_hint, result);\n        }\n        /**\n         * @__sig ippppp\n         */\n        function napi_create_dataview(env, byte_length, arraybuffer, byte_offset, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!arraybuffer)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                byte_length = byte_length >>> 0;\n                byte_offset = byte_offset >>> 0;\n                var handle = emnapiCtx.handleStore.get(arraybuffer);\n                var buffer = handle.value;\n                if (!(buffer instanceof ArrayBuffer)) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                if ((byte_length + byte_offset) > buffer.byteLength) {\n                    var err = new RangeError('byte_offset + byte_length should be less than or equal to the size in bytes of the array passed in');\n                    err.code = 'ERR_NAPI_INVALID_DATAVIEW_ARGS';\n                    throw err;\n                }\n                var dataview = new DataView(buffer, byte_offset, byte_length);\n                if (buffer === wasmMemory.buffer) {\n                    if (!emnapiExternalMemory.wasmMemoryViewTable.has(dataview)) {\n                        emnapiExternalMemory.wasmMemoryViewTable.set(dataview, {\n                            Ctor: DataView,\n                            address: byte_offset,\n                            length: byte_length,\n                            ownership: 1 /* Ownership.kUserland */,\n                            runtimeAllocated: 0\n                        });\n                    }\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                value = emnapiCtx.addToCurrentScope(dataview).id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /**\n         * @__sig ipppp\n         */\n        function node_api_symbol_for(env, utf8description, length, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var autoLength = length === -1;\n            var sizelength = length >>> 0;\n            if (length !== 0) {\n                if (!utf8description)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            }\n            if (!(autoLength || (sizelength <= 2147483647))) {\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            }\n            var descriptionString = emnapiString.UTF8ToString(utf8description, length);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = emnapiCtx.addToCurrentScope(Symbol.for(descriptionString)).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        var createMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_create_array: napi_create_array,\n            napi_create_array_with_length: napi_create_array_with_length,\n            napi_create_arraybuffer: napi_create_arraybuffer,\n            napi_create_buffer: napi_create_buffer,\n            napi_create_buffer_copy: napi_create_buffer_copy,\n            napi_create_dataview: napi_create_dataview,\n            napi_create_date: napi_create_date,\n            napi_create_external: napi_create_external,\n            napi_create_external_arraybuffer: napi_create_external_arraybuffer,\n            napi_create_external_buffer: napi_create_external_buffer,\n            napi_create_object: napi_create_object,\n            napi_create_symbol: napi_create_symbol,\n            napi_create_typedarray: napi_create_typedarray,\n            node_api_symbol_for: node_api_symbol_for\n        });\n        /** @__sig ipip */\n        function napi_get_boolean(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v = value === 0 ? 3 /* GlobalHandle.FALSE */ : 4 /* GlobalHandle.TRUE */;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, v, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipp */\n        function napi_get_global(env, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = 5 /* GlobalHandle.GLOBAL */;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipp */\n        function napi_get_null(env, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = 2 /* GlobalHandle.NULL */;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipp */\n        function napi_get_undefined(env, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = 1 /* GlobalHandle.UNDEFINED */;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        var globalMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_get_boolean: napi_get_boolean,\n            napi_get_global: napi_get_global,\n            napi_get_null: napi_get_null,\n            napi_get_undefined: napi_get_undefined\n        });\n        /** @__sig ipppp */\n        function napi_set_instance_data(env, data, finalize_cb, finalize_hint) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.setInstanceData(data, finalize_cb, finalize_hint);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipp */\n        function napi_get_instance_data(env, data) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            var envObject = emnapiCtx.envStore.get(env);\n            if (!data)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = envObject.getInstanceData();\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(data, value, true);\n            return envObject.clearLastError();\n        }\n        var envMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_get_instance_data: napi_get_instance_data,\n            napi_set_instance_data: napi_set_instance_data\n        });\n        /** @__sig vpppp */\n        function _emnapi_get_last_error_info(env, error_code, engine_error_code, engine_reserved) {\n            var envObject = emnapiCtx.envStore.get(env);\n            var lastError = envObject.lastError;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var errorCode = lastError.errorCode;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var engineErrorCode = lastError.engineErrorCode >>> 0;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var engineReserved = lastError.engineReserved;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(error_code, errorCode, true);\n            HEAP_DATA_VIEW.setUint32(engine_error_code, engineErrorCode, true);\n            HEAP_DATA_VIEW.setInt32(engine_reserved, engineReserved, true);\n        }\n        /** @__sig ipp */\n        function napi_throw(env, error) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!error)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                envObject.tryCatch.setError(emnapiCtx.handleStore.get(error).value);\n                return envObject.clearLastError();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_throw_error(env, code, msg) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!msg)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var error = new Error(emnapiString.UTF8ToString(msg, -1));\n                if (code)\n                    error.code = emnapiString.UTF8ToString(code, -1);\n                envObject.tryCatch.setError(error);\n                return envObject.clearLastError();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_throw_type_error(env, code, msg) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!msg)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var error = new TypeError(emnapiString.UTF8ToString(msg, -1));\n                if (code)\n                    error.code = emnapiString.UTF8ToString(code, -1);\n                envObject.tryCatch.setError(error);\n                return envObject.clearLastError();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_throw_range_error(env, code, msg) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!msg)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var error = new RangeError(emnapiString.UTF8ToString(msg, -1));\n                if (code)\n                    error.code = emnapiString.UTF8ToString(code, -1);\n                envObject.tryCatch.setError(error);\n                return envObject.clearLastError();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function node_api_throw_syntax_error(env, code, msg) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!msg)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var error = new SyntaxError(emnapiString.UTF8ToString(msg, -1));\n                if (code)\n                    error.code = emnapiString.UTF8ToString(code, -1);\n                envObject.tryCatch.setError(error);\n                return envObject.clearLastError();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipp */\n        function napi_is_exception_pending(env, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = envObject.tryCatch.hasCaught();\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt8(result, r ? 1 : 0, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipppp */\n        function napi_create_error(env, code, msg, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!msg)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var msgValue = emnapiCtx.handleStore.get(msg).value;\n            if (typeof msgValue !== 'string') {\n                return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n            }\n            var error = new Error(msgValue);\n            if (code) {\n                var codeValue = emnapiCtx.handleStore.get(code).value;\n                if (typeof codeValue !== 'string') {\n                    return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n                }\n                error.code = codeValue;\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = emnapiCtx.addToCurrentScope(error).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipppp */\n        function napi_create_type_error(env, code, msg, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!msg)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var msgValue = emnapiCtx.handleStore.get(msg).value;\n            if (typeof msgValue !== 'string') {\n                return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n            }\n            var error = new TypeError(msgValue);\n            if (code) {\n                var codeValue = emnapiCtx.handleStore.get(code).value;\n                if (typeof codeValue !== 'string') {\n                    return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n                }\n                error.code = codeValue;\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = emnapiCtx.addToCurrentScope(error).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipppp */\n        function napi_create_range_error(env, code, msg, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!msg)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var msgValue = emnapiCtx.handleStore.get(msg).value;\n            if (typeof msgValue !== 'string') {\n                return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n            }\n            var error = new RangeError(msgValue);\n            if (code) {\n                var codeValue = emnapiCtx.handleStore.get(code).value;\n                if (typeof codeValue !== 'string') {\n                    return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n                }\n                error.code = codeValue;\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = emnapiCtx.addToCurrentScope(error).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipppp */\n        function node_api_create_syntax_error(env, code, msg, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!msg)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var msgValue = emnapiCtx.handleStore.get(msg).value;\n            if (typeof msgValue !== 'string') {\n                return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n            }\n            var error = new SyntaxError(msgValue);\n            if (code) {\n                var codeValue = emnapiCtx.handleStore.get(code).value;\n                if (typeof codeValue !== 'string') {\n                    return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n                }\n                error.code = codeValue;\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = emnapiCtx.addToCurrentScope(error).id;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipp */\n        function napi_get_and_clear_last_exception(env, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if (!envObject.tryCatch.hasCaught()) {\n                HEAP_DATA_VIEW.setInt32(result, 1, true); // ID_UNDEFINED\n                return envObject.clearLastError();\n            }\n            else {\n                var err = envObject.tryCatch.exception();\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var value = envObject.ensureHandleId(err);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                envObject.tryCatch.reset();\n            }\n            return envObject.clearLastError();\n        }\n        /** @__sig vpppp */\n        function napi_fatal_error(location, location_len, message, message_len) {\n            var locationStr = emnapiString.UTF8ToString(location, location_len);\n            var messageStr = emnapiString.UTF8ToString(message, message_len);\n            if (emnapiNodeBinding) {\n                emnapiNodeBinding.napi.fatalError(locationStr, messageStr);\n            }\n            else {\n                abort('FATAL ERROR: ' + locationStr + ' ' + messageStr);\n            }\n        }\n        /** @__sig ipp */\n        function napi_fatal_exception(env, err) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!err)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var error = envObject.ctx.handleStore.get(err);\n                try {\n                    envObject.triggerFatalException(error.value);\n                }\n                catch (_) {\n                    return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n                }\n                return envObject.clearLastError();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        var errorMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            _emnapi_get_last_error_info: _emnapi_get_last_error_info,\n            napi_create_error: napi_create_error,\n            napi_create_range_error: napi_create_range_error,\n            napi_create_type_error: napi_create_type_error,\n            napi_fatal_error: napi_fatal_error,\n            napi_fatal_exception: napi_fatal_exception,\n            napi_get_and_clear_last_exception: napi_get_and_clear_last_exception,\n            napi_is_exception_pending: napi_is_exception_pending,\n            napi_throw: napi_throw,\n            napi_throw_error: napi_throw_error,\n            napi_throw_range_error: napi_throw_range_error,\n            napi_throw_type_error: napi_throw_type_error,\n            node_api_create_syntax_error: node_api_create_syntax_error,\n            node_api_throw_syntax_error: node_api_throw_syntax_error\n        });\n        /** @__sig ipppppp */\n        function napi_create_function(env, utf8name, length, cb, data, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!cb)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var fresult = emnapiCreateFunction(envObject, utf8name, length, cb, data);\n                if (fresult.status !== 0 /* napi_status.napi_ok */)\n                    return envObject.setLastError(fresult.status);\n                var f = fresult.f;\n                var valueHandle = emnapiCtx.addToCurrentScope(f);\n                value = valueHandle.id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipppppp */\n        function napi_get_cb_info(env, cbinfo, argc, argv, this_arg, data) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            var envObject = emnapiCtx.envStore.get(env);\n            if (!cbinfo)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var cbinfoValue = emnapiCtx.cbinfoStack.get(cbinfo);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            if (argv) {\n                if (!argc)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var argcValue = HEAP_DATA_VIEW.getUint32(argc, true);\n                var len = cbinfoValue.args.length;\n                var arrlen = argcValue < len ? argcValue : len;\n                var i = 0;\n                for (; i < arrlen; i++) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    var argVal = envObject.ensureHandleId(cbinfoValue.args[i]);\n                    HEAP_DATA_VIEW.setInt32(argv + i * 4, argVal, true);\n                }\n                if (i < argcValue) {\n                    for (; i < argcValue; i++) {\n                        HEAP_DATA_VIEW.setInt32(argv + i * 4, 1, true);\n                    }\n                }\n            }\n            if (argc) {\n                HEAP_DATA_VIEW.setUint32(argc, cbinfoValue.args.length, true);\n            }\n            if (this_arg) {\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var v = envObject.ensureHandleId(cbinfoValue.thiz);\n                HEAP_DATA_VIEW.setInt32(this_arg, v, true);\n            }\n            if (data) {\n                HEAP_DATA_VIEW.setInt32(data, cbinfoValue.data, true);\n            }\n            return envObject.clearLastError();\n        }\n        /** @__sig ipppppp */\n        function napi_call_function(env, recv, func, argc, argv, result) {\n            var i = 0;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!recv)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                argc = argc >>> 0;\n                if (argc > 0) {\n                    if (!argv)\n                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var v8recv = emnapiCtx.handleStore.get(recv).value;\n                if (!func)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var v8func = emnapiCtx.handleStore.get(func).value;\n                if (typeof v8func !== 'function')\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var args = [];\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                for (; i < argc; i++) {\n                    var argVal = HEAP_DATA_VIEW.getInt32(argv + i * 4, true);\n                    args.push(emnapiCtx.handleStore.get(argVal).value);\n                }\n                var ret = v8func.apply(v8recv, args);\n                if (result) {\n                    v = envObject.ensureHandleId(ret);\n                    HEAP_DATA_VIEW.setInt32(result, v, true);\n                }\n                return envObject.clearLastError();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippppp */\n        function napi_new_instance(env, constructor, argc, argv, result) {\n            var i;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!constructor)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                argc = argc >>> 0;\n                if (argc > 0) {\n                    if (!argv)\n                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var Ctor = emnapiCtx.handleStore.get(constructor).value;\n                if (typeof Ctor !== 'function')\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var ret = void 0;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                if (emnapiCtx.feature.supportReflect) {\n                    var argList = Array(argc);\n                    for (i = 0; i < argc; i++) {\n                        var argVal = HEAP_DATA_VIEW.getInt32(argv + i * 4, true);\n                        argList[i] = emnapiCtx.handleStore.get(argVal).value;\n                    }\n                    ret = Reflect.construct(Ctor, argList, Ctor);\n                }\n                else {\n                    var args = Array(argc + 1);\n                    args[0] = undefined;\n                    for (i = 0; i < argc; i++) {\n                        var argVal = HEAP_DATA_VIEW.getInt32(argv + i * 4, true);\n                        args[i + 1] = emnapiCtx.handleStore.get(argVal).value;\n                    }\n                    var BoundCtor = Ctor.bind.apply(Ctor, args);\n                    ret = new BoundCtor();\n                }\n                if (result) {\n                    v = envObject.ensureHandleId(ret);\n                    HEAP_DATA_VIEW.setInt32(result, v, true);\n                }\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_get_new_target(env, cbinfo, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!cbinfo)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var cbinfoValue = emnapiCtx.cbinfoStack.get(cbinfo);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value = cbinfoValue.getNewTarget(envObject);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, value, true);\n            return envObject.clearLastError();\n        }\n        var functionMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_call_function: napi_call_function,\n            napi_create_function: napi_create_function,\n            napi_get_cb_info: napi_get_cb_info,\n            napi_get_new_target: napi_get_new_target,\n            napi_new_instance: napi_new_instance\n        });\n        /** @__sig ipp */\n        function napi_open_handle_scope(env, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var scope = emnapiCtx.openScope(envObject);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, scope.id, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipp */\n        function napi_close_handle_scope(env, scope) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!scope)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if ((envObject.openHandleScopes === 0)) {\n                return 13 /* napi_status.napi_handle_scope_mismatch */;\n            }\n            emnapiCtx.closeScope(envObject);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipp */\n        function napi_open_escapable_handle_scope(env, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var scope = emnapiCtx.openScope(envObject);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, scope.id, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipp */\n        function napi_close_escapable_handle_scope(env, scope) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!scope)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if ((envObject.openHandleScopes === 0)) {\n                return 13 /* napi_status.napi_handle_scope_mismatch */;\n            }\n            emnapiCtx.closeScope(envObject);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipppp */\n        function napi_escape_handle(env, scope, escapee, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!scope)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!escapee)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var scopeObject = emnapiCtx.scopeStore.get(scope);\n            if (!scopeObject.escapeCalled()) {\n                var newHandle = scopeObject.escape(escapee);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                var value = newHandle ? newHandle.id : 0;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.clearLastError();\n            }\n            return envObject.setLastError(12 /* napi_status.napi_escape_called_twice */);\n        }\n        /** @__sig ippip */\n        function napi_create_reference(env, value, initial_refcount, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var handle = emnapiCtx.handleStore.get(value);\n            if (envObject.moduleApiVersion !== 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */) {\n                if (!(handle.isObject() || handle.isFunction() || handle.isSymbol())) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var ref = emnapiCtx.createReference(envObject, handle.id, initial_refcount >>> 0, 1 /* Ownership.kUserland */);\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, ref.id, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipp */\n        function napi_delete_reference(env, ref) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!ref)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            emnapiCtx.refStore.get(ref).dispose();\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_reference_ref(env, ref, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!ref)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var count = emnapiCtx.refStore.get(ref).ref();\n            if (result) {\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setUint32(result, count, true);\n            }\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_reference_unref(env, ref, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!ref)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var reference = emnapiCtx.refStore.get(ref);\n            var refcount = reference.refCount();\n            if (refcount === 0) {\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var count = reference.unref();\n            if (result) {\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setUint32(result, count, true);\n            }\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_get_reference_value(env, ref, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!ref)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var reference = emnapiCtx.refStore.get(ref);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var handleId = reference.get();\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, handleId, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_add_env_cleanup_hook(env, fun, arg) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            var envObject = emnapiCtx.envStore.get(env);\n            if (!fun)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            emnapiCtx.addCleanupHook(envObject, fun, arg);\n            return 0 /* napi_status.napi_ok */;\n        }\n        /** @__sig ippp */\n        function napi_remove_env_cleanup_hook(env, fun, arg) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            var envObject = emnapiCtx.envStore.get(env);\n            if (!fun)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            emnapiCtx.removeCleanupHook(envObject, fun, arg);\n            return 0 /* napi_status.napi_ok */;\n        }\n        /** @__sig vp */\n        function _emnapi_env_ref(env) {\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.ref();\n        }\n        /** @__sig vp */\n        function _emnapi_env_unref(env) {\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.unref();\n        }\n        var lifeMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            _emnapi_env_ref: _emnapi_env_ref,\n            _emnapi_env_unref: _emnapi_env_unref,\n            napi_add_env_cleanup_hook: napi_add_env_cleanup_hook,\n            napi_close_escapable_handle_scope: napi_close_escapable_handle_scope,\n            napi_close_handle_scope: napi_close_handle_scope,\n            napi_create_reference: napi_create_reference,\n            napi_delete_reference: napi_delete_reference,\n            napi_escape_handle: napi_escape_handle,\n            napi_get_reference_value: napi_get_reference_value,\n            napi_open_escapable_handle_scope: napi_open_escapable_handle_scope,\n            napi_open_handle_scope: napi_open_handle_scope,\n            napi_reference_ref: napi_reference_ref,\n            napi_reference_unref: napi_reference_unref,\n            napi_remove_env_cleanup_hook: napi_remove_env_cleanup_hook\n        });\n        /** @__sig ippi */\n        function _emnapi_get_filename(env, buf, len) {\n            var envObject = emnapiCtx.envStore.get(env);\n            var filename = envObject.filename;\n            if (!buf) {\n                return emnapiString.lengthBytesUTF8(filename);\n            }\n            return emnapiString.stringToUTF8(filename, buf, len);\n        }\n        var miscellaneousMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            _emnapi_get_filename: _emnapi_get_filename\n        });\n        /** @__sig ippp */\n        function napi_create_promise(env, deferred, promise) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var deferredObjectId, value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!deferred)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!promise)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                var p = new Promise(function (resolve, reject) {\n                    var deferredObject = emnapiCtx.createDeferred({ resolve: resolve, reject: reject });\n                    deferredObjectId = deferredObject.id;\n                    HEAP_DATA_VIEW.setInt32(deferred, deferredObjectId, true);\n                });\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                value = emnapiCtx.addToCurrentScope(p).id;\n                HEAP_DATA_VIEW.setInt32(promise, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_resolve_deferred(env, deferred, resolution) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!deferred)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!resolution)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var deferredObject = emnapiCtx.deferredStore.get(deferred);\n                deferredObject.resolve(emnapiCtx.handleStore.get(resolution).value);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_reject_deferred(env, deferred, resolution) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!deferred)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!resolution)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var deferredObject = emnapiCtx.deferredStore.get(deferred);\n                deferredObject.reject(emnapiCtx.handleStore.get(resolution).value);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_is_promise(env, value, is_promise) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!is_promise)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var h = emnapiCtx.handleStore.get(value);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = h.isPromise() ? 1 : 0;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt8(is_promise, r, true);\n            return envObject.clearLastError();\n        }\n        var promiseMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_create_promise: napi_create_promise,\n            napi_is_promise: napi_is_promise,\n            napi_reject_deferred: napi_reject_deferred,\n            napi_resolve_deferred: napi_resolve_deferred\n        });\n        /** @__sig ippiiip */\n        function napi_get_all_property_names(env, object, key_mode, key_filter, key_conversion, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (h.value == null) {\n                    throw new TypeError('Cannot convert undefined or null to object');\n                }\n                var obj = void 0;\n                try {\n                    obj = h.isObject() || h.isFunction() ? h.value : Object(h.value);\n                }\n                catch (_) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                if (key_mode !== 0 /* napi_key_collection_mode.napi_key_include_prototypes */ && key_mode !== 1 /* napi_key_collection_mode.napi_key_own_only */) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                if (key_conversion !== 0 /* napi_key_conversion.napi_key_keep_numbers */ && key_conversion !== 1 /* napi_key_conversion.napi_key_numbers_to_strings */) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var props = [];\n                var names = void 0;\n                var symbols = void 0;\n                var i = void 0;\n                var own = true;\n                var integerIndiceRegex = /^(0|[1-9][0-9]*)$/;\n                do {\n                    names = Object.getOwnPropertyNames(obj);\n                    symbols = Object.getOwnPropertySymbols(obj);\n                    for (i = 0; i < names.length; i++) {\n                        props.push({\n                            name: integerIndiceRegex.test(names[i]) ? Number(names[i]) : names[i],\n                            desc: Object.getOwnPropertyDescriptor(obj, names[i]),\n                            own: own\n                        });\n                    }\n                    for (i = 0; i < symbols.length; i++) {\n                        props.push({\n                            name: symbols[i],\n                            desc: Object.getOwnPropertyDescriptor(obj, symbols[i]),\n                            own: own\n                        });\n                    }\n                    if (key_mode === 1 /* napi_key_collection_mode.napi_key_own_only */) {\n                        break;\n                    }\n                    obj = Object.getPrototypeOf(obj);\n                    own = false;\n                } while (obj);\n                var ret = [];\n                var addName = function (ret, name, key_filter, conversion_mode) {\n                    if (ret.indexOf(name) !== -1)\n                        return;\n                    if (conversion_mode === 0 /* napi_key_conversion.napi_key_keep_numbers */) {\n                        ret.push(name);\n                    }\n                    else if (conversion_mode === 1 /* napi_key_conversion.napi_key_numbers_to_strings */) {\n                        var realName = typeof name === 'number' ? String(name) : name;\n                        if (typeof realName === 'string') {\n                            if (!(key_filter & 8 /* napi_key_filter.napi_key_skip_strings */)) {\n                                ret.push(realName);\n                            }\n                        }\n                        else {\n                            ret.push(realName);\n                        }\n                    }\n                };\n                for (i = 0; i < props.length; i++) {\n                    var prop = props[i];\n                    var name_1 = prop.name;\n                    var desc = prop.desc;\n                    if (key_filter === 0 /* napi_key_filter.napi_key_all_properties */) {\n                        addName(ret, name_1, key_filter, key_conversion);\n                    }\n                    else {\n                        if (key_filter & 8 /* napi_key_filter.napi_key_skip_strings */ && typeof name_1 === 'string') {\n                            continue;\n                        }\n                        if (key_filter & 16 /* napi_key_filter.napi_key_skip_symbols */ && typeof name_1 === 'symbol') {\n                            continue;\n                        }\n                        var shouldAdd = true;\n                        switch (key_filter & 7) {\n                            case 1 /* napi_key_filter.napi_key_writable */: {\n                                shouldAdd = Boolean(desc.writable);\n                                break;\n                            }\n                            case 2 /* napi_key_filter.napi_key_enumerable */: {\n                                shouldAdd = Boolean(desc.enumerable);\n                                break;\n                            }\n                            case (1 /* napi_key_filter.napi_key_writable */ | 2 /* napi_key_filter.napi_key_enumerable */): {\n                                shouldAdd = Boolean(desc.writable && desc.enumerable);\n                                break;\n                            }\n                            case 4 /* napi_key_filter.napi_key_configurable */: {\n                                shouldAdd = Boolean(desc.configurable);\n                                break;\n                            }\n                            case (4 /* napi_key_filter.napi_key_configurable */ | 1 /* napi_key_filter.napi_key_writable */): {\n                                shouldAdd = Boolean(desc.configurable && desc.writable);\n                                break;\n                            }\n                            case (4 /* napi_key_filter.napi_key_configurable */ | 2 /* napi_key_filter.napi_key_enumerable */): {\n                                shouldAdd = Boolean(desc.configurable && desc.enumerable);\n                                break;\n                            }\n                            case (4 /* napi_key_filter.napi_key_configurable */ | 2 /* napi_key_filter.napi_key_enumerable */ | 1 /* napi_key_filter.napi_key_writable */): {\n                                shouldAdd = Boolean(desc.configurable && desc.enumerable && desc.writable);\n                                break;\n                            }\n                        }\n                        if (shouldAdd) {\n                            addName(ret, name_1, key_filter, key_conversion);\n                        }\n                    }\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                value = emnapiCtx.addToCurrentScope(ret).id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_get_property_names(env, object, result) {\n            return napi_get_all_property_names(env, object, 0 /* napi_key_collection_mode.napi_key_include_prototypes */, 2 /* napi_key_filter.napi_key_enumerable */ | 16 /* napi_key_filter.napi_key_skip_symbols */, 1 /* napi_key_conversion.napi_key_numbers_to_strings */, result);\n        }\n        /** @__sig ipppp */\n        function napi_set_property(env, object, key, value) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!key)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!value)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (!(h.isObject() || h.isFunction())) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                h.value[emnapiCtx.handleStore.get(key).value] = emnapiCtx.handleStore.get(value).value;\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipppp */\n        function napi_has_property(env, object, key, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!key)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (h.value == null) {\n                    throw new TypeError('Cannot convert undefined or null to object');\n                }\n                var v = void 0;\n                try {\n                    v = h.isObject() || h.isFunction() ? h.value : Object(h.value);\n                }\n                catch (_) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                r = (emnapiCtx.handleStore.get(key).value in v) ? 1 : 0;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt8(result, r, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipppp */\n        function napi_get_property(env, object, key, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!key)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (h.value == null) {\n                    throw new TypeError('Cannot convert undefined or null to object');\n                }\n                var v = void 0;\n                try {\n                    v = h.isObject() || h.isFunction() ? h.value : Object(h.value);\n                }\n                catch (_) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                value = envObject.ensureHandleId(v[emnapiCtx.handleStore.get(key).value]);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipppp */\n        function napi_delete_property(env, object, key, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!key)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (!(h.isObject() || h.isFunction())) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                var propertyKey = emnapiCtx.handleStore.get(key).value;\n                if (emnapiCtx.feature.supportReflect) {\n                    r = Reflect.deleteProperty(h.value, propertyKey);\n                }\n                else {\n                    try {\n                        r = delete h.value[propertyKey];\n                    }\n                    catch (_) {\n                        r = false;\n                    }\n                }\n                if (result) {\n                    var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                    HEAP_DATA_VIEW.setInt8(result, r ? 1 : 0, true);\n                }\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipppp */\n        function napi_has_own_property(env, object, key, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!key)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (h.value == null) {\n                    throw new TypeError('Cannot convert undefined or null to object');\n                }\n                var v = void 0;\n                try {\n                    v = h.isObject() || h.isFunction() ? h.value : Object(h.value);\n                }\n                catch (_) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                var prop = emnapiCtx.handleStore.get(key).value;\n                if (typeof prop !== 'string' && typeof prop !== 'symbol') {\n                    return envObject.setLastError(4 /* napi_status.napi_name_expected */);\n                }\n                r = Object.prototype.hasOwnProperty.call(v, emnapiCtx.handleStore.get(key).value);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt8(result, r ? 1 : 0, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipppp */\n        function napi_set_named_property(env, object, cname, value) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!value)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (!(h.isObject() || h.isFunction())) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                if (!cname) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                emnapiCtx.handleStore.get(object).value[emnapiString.UTF8ToString(cname, -1)] = emnapiCtx.handleStore.get(value).value;\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipppp */\n        function napi_has_named_property(env, object, utf8name, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!utf8name) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var h = emnapiCtx.handleStore.get(object);\n                if (h.value == null) {\n                    throw new TypeError('Cannot convert undefined or null to object');\n                }\n                var v = void 0;\n                try {\n                    v = h.isObject() || h.isFunction() ? h.value : Object(h.value);\n                }\n                catch (_) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                r = emnapiString.UTF8ToString(utf8name, -1) in v;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt8(result, r ? 1 : 0, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipppp */\n        function napi_get_named_property(env, object, utf8name, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!utf8name) {\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                var h = emnapiCtx.handleStore.get(object);\n                if (h.value == null) {\n                    throw new TypeError('Cannot convert undefined or null to object');\n                }\n                var v = void 0;\n                try {\n                    v = h.isObject() || h.isFunction() ? h.value : Object(h.value);\n                }\n                catch (_) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                value = envObject.ensureHandleId(v[emnapiString.UTF8ToString(utf8name, -1)]);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippip */\n        function napi_set_element(env, object, index, value) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!value)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (!(h.isObject() || h.isFunction())) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                h.value[index >>> 0] = emnapiCtx.handleStore.get(value).value;\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippip */\n        function napi_has_element(env, object, index, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (h.value == null) {\n                    throw new TypeError('Cannot convert undefined or null to object');\n                }\n                var v = void 0;\n                try {\n                    v = h.isObject() || h.isFunction() ? h.value : Object(h.value);\n                }\n                catch (_) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                r = ((index >>> 0) in v) ? 1 : 0;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt8(result, r, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippip */\n        function napi_get_element(env, object, index, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (h.value == null) {\n                    throw new TypeError('Cannot convert undefined or null to object');\n                }\n                var v = void 0;\n                try {\n                    v = h.isObject() || h.isFunction() ? h.value : Object(h.value);\n                }\n                catch (_) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                value = envObject.ensureHandleId(v[index >>> 0]);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippip */\n        function napi_delete_element(env, object, index, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                if (!(h.isObject() || h.isFunction())) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                if (emnapiCtx.feature.supportReflect) {\n                    r = Reflect.deleteProperty(h.value, index >>> 0);\n                }\n                else {\n                    try {\n                        r = delete h.value[index >>> 0];\n                    }\n                    catch (_) {\n                        r = false;\n                    }\n                }\n                if (result) {\n                    var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                    HEAP_DATA_VIEW.setInt8(result, r ? 1 : 0, true);\n                }\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipppp */\n        function napi_define_properties(env, object, property_count, properties) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var propPtr, attributes;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                property_count = property_count >>> 0;\n                if (property_count > 0) {\n                    if (!properties)\n                        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                }\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                var maybeObject = h.value;\n                if (!(h.isObject() || h.isFunction())) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                var propertyName = void 0;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                for (var i = 0; i < property_count; i++) {\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    propPtr = properties + (i * (4 * 8));\n                    var utf8Name = HEAP_DATA_VIEW.getInt32(propPtr, true);\n                    var name_2 = HEAP_DATA_VIEW.getInt32(propPtr + 4, true);\n                    var method = HEAP_DATA_VIEW.getInt32(propPtr + 8, true);\n                    var getter = HEAP_DATA_VIEW.getInt32(propPtr + 12, true);\n                    var setter = HEAP_DATA_VIEW.getInt32(propPtr + 16, true);\n                    var value = HEAP_DATA_VIEW.getInt32(propPtr + 20, true);\n                    attributes = HEAP_DATA_VIEW.getInt32(propPtr + 24, true);\n                    var data = HEAP_DATA_VIEW.getInt32(propPtr + 28, true);\n                    if (utf8Name) {\n                        propertyName = emnapiString.UTF8ToString(utf8Name, -1);\n                    }\n                    else {\n                        if (!name_2) {\n                            return envObject.setLastError(4 /* napi_status.napi_name_expected */);\n                        }\n                        propertyName = emnapiCtx.handleStore.get(name_2).value;\n                        if (typeof propertyName !== 'string' && typeof propertyName !== 'symbol') {\n                            return envObject.setLastError(4 /* napi_status.napi_name_expected */);\n                        }\n                    }\n                    emnapiDefineProperty(envObject, maybeObject, propertyName, method, getter, setter, value, attributes, data);\n                }\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipp */\n        function napi_object_freeze(env, object) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                var maybeObject = h.value;\n                if (!(h.isObject() || h.isFunction())) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                Object.freeze(maybeObject);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipp */\n        function napi_object_seal(env, object) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(object);\n                var maybeObject = h.value;\n                if (!(h.isObject() || h.isFunction())) {\n                    return envObject.setLastError(2 /* napi_status.napi_object_expected */);\n                }\n                Object.seal(maybeObject);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        var propertyMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_define_properties: napi_define_properties,\n            napi_delete_element: napi_delete_element,\n            napi_delete_property: napi_delete_property,\n            napi_get_all_property_names: napi_get_all_property_names,\n            napi_get_element: napi_get_element,\n            napi_get_named_property: napi_get_named_property,\n            napi_get_property: napi_get_property,\n            napi_get_property_names: napi_get_property_names,\n            napi_has_element: napi_has_element,\n            napi_has_named_property: napi_has_named_property,\n            napi_has_own_property: napi_has_own_property,\n            napi_has_property: napi_has_property,\n            napi_object_freeze: napi_object_freeze,\n            napi_object_seal: napi_object_seal,\n            napi_set_element: napi_set_element,\n            napi_set_named_property: napi_set_named_property,\n            napi_set_property: napi_set_property\n        });\n        /** @__sig ippp */\n        function napi_run_script(env, script, result) {\n            var status;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var value;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!script)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var v8Script = emnapiCtx.handleStore.get(script);\n                if (!v8Script.isString()) {\n                    return envObject.setLastError(3 /* napi_status.napi_string_expected */);\n                }\n                var g = emnapiCtx.handleStore.get(5 /* GlobalHandle.GLOBAL */).value;\n                var ret = g.eval(v8Script.value);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                value = envObject.ensureHandleId(ret);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, value, true);\n                status = envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n            return status;\n        }\n        var scriptMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_run_script: napi_run_script\n        });\n        /** @__sig ippp */\n        function napi_typeof(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var v = emnapiCtx.handleStore.get(value);\n            var r;\n            if (v.isNumber()) {\n                r = 3 /* napi_valuetype.napi_number */;\n            }\n            else if (v.isBigInt()) {\n                r = 9 /* napi_valuetype.napi_bigint */;\n            }\n            else if (v.isString()) {\n                r = 4 /* napi_valuetype.napi_string */;\n            }\n            else if (v.isFunction()) {\n                // This test has to come before IsObject because IsFunction\n                // implies IsObject\n                r = 7 /* napi_valuetype.napi_function */;\n            }\n            else if (v.isExternal()) {\n                // This test has to come before IsObject because IsExternal\n                // implies IsObject\n                r = 8 /* napi_valuetype.napi_external */;\n            }\n            else if (v.isObject()) {\n                r = 6 /* napi_valuetype.napi_object */;\n            }\n            else if (v.isBoolean()) {\n                r = 2 /* napi_valuetype.napi_boolean */;\n            }\n            else if (v.isUndefined()) {\n                r = 0 /* napi_valuetype.napi_undefined */;\n            }\n            else if (v.isSymbol()) {\n                r = 5 /* napi_valuetype.napi_symbol */;\n            }\n            else if (v.isNull()) {\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                r = 1 /* napi_valuetype.napi_null */;\n            }\n            else {\n                // Should not get here unless V8 has added some new kind of value.\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            }\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt32(result, r, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_coerce_to_bool(env, value, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!value)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var handle = emnapiCtx.handleStore.get(value);\n                v = handle.value ? 4 /* GlobalHandle.TRUE */ : 3 /* GlobalHandle.FALSE */;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, v, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_coerce_to_number(env, value, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!value)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var handle = emnapiCtx.handleStore.get(value);\n                if (handle.isBigInt()) {\n                    throw new TypeError('Cannot convert a BigInt value to a number');\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                v = emnapiCtx.addToCurrentScope(Number(handle.value)).id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, v, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_coerce_to_object(env, value, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!value)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var handle = emnapiCtx.handleStore.get(value);\n                if (handle.value == null) {\n                    throw new TypeError('Cannot convert undefined or null to object');\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                v = envObject.ensureHandleId(Object(handle.value));\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, v, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_coerce_to_string(env, value, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var v;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!value)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var handle = emnapiCtx.handleStore.get(value);\n                if (handle.isSymbol()) {\n                    throw new TypeError('Cannot convert a Symbol value to a string');\n                }\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                v = emnapiCtx.addToCurrentScope(String(handle.value)).id;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt32(result, v, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipppp */\n        function napi_instanceof(env, object, constructor, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!object)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!constructor)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt8(result, 0, true);\n                var ctor = emnapiCtx.handleStore.get(constructor);\n                if (!ctor.isFunction()) {\n                    return envObject.setLastError(5 /* napi_status.napi_function_expected */);\n                }\n                var val = emnapiCtx.handleStore.get(object).value;\n                var ret = val instanceof ctor.value;\n                r = ret ? 1 : 0;\n                HEAP_DATA_VIEW.setInt8(result, r, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ippp */\n        function napi_is_array(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var h = emnapiCtx.handleStore.get(value);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = h.isArray() ? 1 : 0;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt8(result, r, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_is_arraybuffer(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var h = emnapiCtx.handleStore.get(value);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = h.isArrayBuffer() ? 1 : 0;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt8(result, r, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_is_date(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var h = emnapiCtx.handleStore.get(value);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = h.isDate() ? 1 : 0;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt8(result, r, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_is_error(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var val = emnapiCtx.handleStore.get(value).value;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = (val instanceof Error) ? 1 : 0;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt8(result, r, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_is_typedarray(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var h = emnapiCtx.handleStore.get(value);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = h.isTypedArray() ? 1 : 0;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt8(result, r, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_is_buffer(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var h = emnapiCtx.handleStore.get(value);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = h.isBuffer() ? 1 : 0;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt8(result, r, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_is_dataview(env, value, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!value)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var h = emnapiCtx.handleStore.get(value);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r = h.isDataView() ? 1 : 0;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setInt8(result, r, true);\n            return envObject.clearLastError();\n        }\n        /** @__sig ipppp */\n        function napi_strict_equals(env, lhs, rhs, result) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var r;\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!lhs)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!rhs)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var lv = emnapiCtx.handleStore.get(lhs).value;\n                var rv = emnapiCtx.handleStore.get(rhs).value;\n                r = (lv === rv) ? 1 : 0;\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                HEAP_DATA_VIEW.setInt8(result, r, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        /** @__sig ipp */\n        function napi_detach_arraybuffer(env, arraybuffer) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!arraybuffer)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            var value = emnapiCtx.handleStore.get(arraybuffer).value;\n            if (!(value instanceof ArrayBuffer)) {\n                if (typeof SharedArrayBuffer === 'function' && (value instanceof SharedArrayBuffer)) {\n                    return envObject.setLastError(20 /* napi_status.napi_detachable_arraybuffer_expected */);\n                }\n                return envObject.setLastError(19 /* napi_status.napi_arraybuffer_expected */);\n            }\n            try {\n                var MessageChannel_1 = emnapiCtx.feature.MessageChannel;\n                var messageChannel = new MessageChannel_1();\n                messageChannel.port1.postMessage(value, [value]);\n            }\n            catch (_) {\n                return envObject.setLastError(9 /* napi_status.napi_generic_failure */);\n            }\n            return envObject.clearLastError();\n        }\n        /** @__sig ippp */\n        function napi_is_detached_arraybuffer(env, arraybuffer, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            // @ts-expect-error\n            var envObject = emnapiCtx.envStore.get(env);\n            envObject.checkGCAccess();\n            if (!envObject.tryCatch.isEmpty())\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            if (!envObject.canCallIntoJs())\n                return envObject.setLastError(envObject.moduleApiVersion === 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */ ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */);\n            envObject.clearLastError();\n            try {\n                if (!arraybuffer)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                if (!result)\n                    return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n                var h = emnapiCtx.handleStore.get(arraybuffer);\n                var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n                if (h.isArrayBuffer() && h.value.byteLength === 0) {\n                    try {\n                        // eslint-disable-next-line no-new\n                        new Uint8Array(h.value);\n                    }\n                    catch (_) {\n                        HEAP_DATA_VIEW.setInt8(result, 1, true);\n                        return envObject.getReturnStatus();\n                    }\n                }\n                HEAP_DATA_VIEW.setInt8(result, 0, true);\n                return envObject.getReturnStatus();\n            }\n            catch (err) {\n                envObject.tryCatch.setError(err);\n                return envObject.setLastError(10 /* napi_status.napi_pending_exception */);\n            }\n        }\n        var valueOperationMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_coerce_to_bool: napi_coerce_to_bool,\n            napi_coerce_to_number: napi_coerce_to_number,\n            napi_coerce_to_object: napi_coerce_to_object,\n            napi_coerce_to_string: napi_coerce_to_string,\n            napi_detach_arraybuffer: napi_detach_arraybuffer,\n            napi_instanceof: napi_instanceof,\n            napi_is_array: napi_is_array,\n            napi_is_arraybuffer: napi_is_arraybuffer,\n            napi_is_buffer: napi_is_buffer,\n            napi_is_dataview: napi_is_dataview,\n            napi_is_date: napi_is_date,\n            napi_is_detached_arraybuffer: napi_is_detached_arraybuffer,\n            napi_is_error: napi_is_error,\n            napi_is_typedarray: napi_is_typedarray,\n            napi_strict_equals: napi_strict_equals,\n            napi_typeof: napi_typeof\n        });\n        /** @__sig ipp */\n        function napi_get_version(env, result) {\n            if (!env)\n                return 1 /* napi_status.napi_invalid_arg */;\n            var envObject = emnapiCtx.envStore.get(env);\n            if (!result)\n                return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            var NODE_API_SUPPORTED_VERSION_MAX = 9 /* Version.NODE_API_SUPPORTED_VERSION_MAX */;\n            var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer);\n            HEAP_DATA_VIEW.setUint32(result, NODE_API_SUPPORTED_VERSION_MAX, true);\n            return envObject.clearLastError();\n        }\n        var versionMod = /*#__PURE__*/ Object.freeze({\n            __proto__: null,\n            napi_get_version: napi_get_version\n        });\n        emnapiAWST.init();\n        emnapiExternalMemory.init();\n        emnapiString.init();\n        emnapiTSFN.init();\n        napiModule.emnapi.syncMemory = $emnapiSyncMemory;\n        napiModule.emnapi.getMemoryAddress = $emnapiGetMemoryAddress;\n        function addImports(mod) {\n            var keys = Object.keys(mod);\n            for (var i = 0; i < keys.length; ++i) {\n                var k = keys[i];\n                if (k.indexOf('$') === 0)\n                    continue;\n                if (k.indexOf('emnapi_') === 0) {\n                    napiModule.imports.emnapi[k] = mod[k];\n                }\n                else if (k.indexOf('_emnapi_') === 0 || k === 'napi_set_last_error' || k === 'napi_clear_last_error') {\n                    napiModule.imports.env[k] = mod[k];\n                }\n                else {\n                    napiModule.imports.napi[k] = mod[k];\n                }\n            }\n        }\n        addImports(asyncMod);\n        addImports(memoryMod);\n        addImports(asyncWorkMod);\n        addImports(utilMod);\n        addImports(convert2cMod);\n        addImports(convert2napiMod);\n        addImports(createMod);\n        addImports(globalMod);\n        addImports(wrapMod);\n        addImports(envMod);\n        addImports(emnapiMod);\n        addImports(errorMod);\n        addImports(functionMod);\n        addImports(lifeMod);\n        addImports(miscellaneousMod);\n        addImports(nodeMod);\n        addImports(promiseMod);\n        addImports(propertyMod);\n        addImports(scriptMod);\n        addImports(valueOperationMod);\n        addImports(versionMod);\n        napiModule.imports.napi.napi_create_threadsafe_function = napi_create_threadsafe_function;\n        napiModule.imports.napi.napi_get_threadsafe_function_context = napi_get_threadsafe_function_context;\n        napiModule.imports.napi.napi_call_threadsafe_function = napi_call_threadsafe_function;\n        napiModule.imports.napi.napi_acquire_threadsafe_function = napi_acquire_threadsafe_function;\n        napiModule.imports.napi.napi_release_threadsafe_function = napi_release_threadsafe_function;\n        napiModule.imports.napi.napi_unref_threadsafe_function = napi_unref_threadsafe_function;\n        napiModule.imports.napi.napi_ref_threadsafe_function = napi_ref_threadsafe_function;\n        return napiModule;\n    })();\n    return napiModule;\n}\n\nfunction loadNapiModuleImpl(loadFn, userNapiModule, wasmInput, options) {\n    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n    options = options !== null && options !== void 0 ? options : {};\n    var getMemory = options.getMemory;\n    var getTable = options.getTable;\n    var beforeInit = options.beforeInit;\n    if (getMemory != null && typeof getMemory !== 'function') {\n        throw new TypeError('options.getMemory is not a function');\n    }\n    if (getTable != null && typeof getTable !== 'function') {\n        throw new TypeError('options.getTable is not a function');\n    }\n    if (beforeInit != null && typeof beforeInit !== 'function') {\n        throw new TypeError('options.beforeInit is not a function');\n    }\n    var napiModule;\n    var isLoad = typeof userNapiModule === 'object' && userNapiModule !== null;\n    if (isLoad) {\n        if (userNapiModule.loaded) {\n            throw new Error('napiModule has already loaded');\n        }\n        napiModule = userNapiModule;\n    }\n    else {\n        napiModule = createNapiModule(options);\n    }\n    var wasi = options.wasi;\n    var importObject = {\n        env: napiModule.imports.env,\n        napi: napiModule.imports.napi,\n        emnapi: napiModule.imports.emnapi,\n        wasi: {\n            // eslint-disable-next-line camelcase\n            'thread-spawn': function __imported_wasi_thread_spawn(startArg, errorOrTid) {\n                return napiModule.spawnThread(startArg, errorOrTid);\n            }\n        }\n    };\n    if (wasi) {\n        Object.assign(importObject, typeof wasi.getImportObject === 'function'\n            ? wasi.getImportObject()\n            : { wasi_snapshot_preview1: wasi.wasiImport });\n    }\n    var overwriteImports = options.overwriteImports;\n    if (typeof overwriteImports === 'function') {\n        var newImportObject = overwriteImports(importObject);\n        if (typeof newImportObject === 'object' && newImportObject !== null) {\n            importObject = newImportObject;\n        }\n    }\n    return loadFn(wasmInput, importObject, function (err, source) {\n        if (err) {\n            throw err;\n        }\n        var originalInstance = source.instance;\n        var instance = originalInstance;\n        var originalExports = originalInstance.exports;\n        var exportMemory = 'memory' in originalExports;\n        var importMemory = 'memory' in importObject.env;\n        var memory = getMemory\n            ? getMemory(originalExports)\n            : exportMemory\n                ? originalExports.memory\n                : importMemory\n                    ? importObject.env.memory\n                    : undefined;\n        if (!memory) {\n            throw new Error('memory is neither exported nor imported');\n        }\n        var table = getTable ? getTable(originalExports) : originalExports.__indirect_function_table;\n        if (wasi && !exportMemory) {\n            var exports_1 = Object.create(null);\n            Object.assign(exports_1, originalExports, { memory: memory });\n            instance = { exports: exports_1 };\n        }\n        var module = source.module;\n        if (wasi) {\n            if (napiModule.childThread) {\n                // https://github.com/nodejs/help/issues/4102\n                var createHandler = function (target) {\n                    var handlers = [\n                        'apply',\n                        'construct',\n                        'defineProperty',\n                        'deleteProperty',\n                        'get',\n                        'getOwnPropertyDescriptor',\n                        'getPrototypeOf',\n                        'has',\n                        'isExtensible',\n                        'ownKeys',\n                        'preventExtensions',\n                        'set',\n                        'setPrototypeOf'\n                    ];\n                    var handler = {};\n                    var _loop_1 = function (i) {\n                        var name_1 = handlers[i];\n                        handler[name_1] = function () {\n                            var args = Array.prototype.slice.call(arguments, 1);\n                            args.unshift(target);\n                            return Reflect[name_1].apply(Reflect, args);\n                        };\n                    };\n                    for (var i = 0; i < handlers.length; i++) {\n                        _loop_1(i);\n                    }\n                    return handler;\n                };\n                var handler = createHandler(originalExports);\n                var noop_1 = function () { };\n                handler.get = function (_target, p, receiver) {\n                    if (p === 'memory') {\n                        return memory;\n                    }\n                    if (p === '_initialize') {\n                        return noop_1;\n                    }\n                    return Reflect.get(originalExports, p, receiver);\n                };\n                var exportsProxy_1 = new Proxy(Object.create(null), handler);\n                instance = new Proxy(instance, {\n                    get: function (target, p, receiver) {\n                        if (p === 'exports') {\n                            return exportsProxy_1;\n                        }\n                        return Reflect.get(target, p, receiver);\n                    }\n                });\n            }\n            wasi.initialize(instance);\n        }\n        if (beforeInit) {\n            beforeInit({\n                instance: originalInstance,\n                module: module\n            });\n        }\n        napiModule.init({\n            instance: instance,\n            module: module,\n            memory: memory,\n            table: table\n        });\n        var ret = { instance: originalInstance, module: module };\n        if (!isLoad) {\n            ret.napiModule = napiModule;\n        }\n        return ret;\n    });\n}\nfunction loadCallback(wasmInput, importObject, callback) {\n    return load(wasmInput, importObject).then(function (source) {\n        return callback(null, source);\n    }, function (err) {\n        return callback(err);\n    });\n}\nfunction loadSyncCallback(wasmInput, importObject, callback) {\n    var source;\n    try {\n        source = loadSync(wasmInput, importObject);\n    }\n    catch (err) {\n        return callback(err);\n    }\n    return callback(null, source);\n}\n/** @public */\nfunction loadNapiModule(napiModule, \n/** Only support `BufferSource` or `WebAssembly.Module` on Node.js */\nwasmInput, options) {\n    if (typeof napiModule !== 'object' || napiModule === null) {\n        throw new TypeError('Invalid napiModule');\n    }\n    return loadNapiModuleImpl(loadCallback, napiModule, wasmInput, options);\n}\n/** @public */\nfunction loadNapiModuleSync(napiModule, wasmInput, options) {\n    if (typeof napiModule !== 'object' || napiModule === null) {\n        throw new TypeError('Invalid napiModule');\n    }\n    return loadNapiModuleImpl(loadSyncCallback, napiModule, wasmInput, options);\n}\n/** @public */\nfunction instantiateNapiModule(\n/** Only support `BufferSource` or `WebAssembly.Module` on Node.js */\nwasmInput, options) {\n    return loadNapiModuleImpl(loadCallback, undefined, wasmInput, options);\n}\n/** @public */\nfunction instantiateNapiModuleSync(wasmInput, options) {\n    return loadNapiModuleImpl(loadSyncCallback, undefined, wasmInput, options);\n}\n\n/** @public */\nvar MessageHandler = /*#__PURE__*/ (function () {\n    function MessageHandler(options) {\n        var onLoad = options.onLoad;\n        if (typeof onLoad !== 'function') {\n            throw new TypeError('options.onLoad is not a function');\n        }\n        this.onLoad = onLoad;\n        this.instance = undefined;\n        // this.module = undefined\n        this.napiModule = undefined;\n        this.messagesBeforeLoad = [];\n    }\n    MessageHandler.prototype.handle = function (e) {\n        var _this = this;\n        var _a;\n        if ((_a = e === null || e === void 0 ? void 0 : e.data) === null || _a === void 0 ? void 0 : _a.__emnapi__) {\n            var type = e.data.__emnapi__.type;\n            var payload_1 = e.data.__emnapi__.payload;\n            var onLoad = this.onLoad;\n            if (type === 'load') {\n                if (this.instance !== undefined)\n                    return;\n                var source = onLoad(payload_1);\n                var then = source && 'then' in source ? source.then : undefined;\n                if (typeof then === 'function') {\n                    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n                    then.call(source, function (source) { onLoaded.call(_this, source); }, function (err) { throw err; });\n                }\n                else {\n                    onLoaded.call(this, source);\n                }\n            }\n            else if (type === 'start') {\n                handleAfterLoad.call(this, e, function () {\n                    _this.napiModule.startThread(payload_1.tid, payload_1.arg);\n                });\n            }\n            else if (type === 'async-worker-init') {\n                handleAfterLoad.call(this, e, function () {\n                    _this.napiModule.initWorker(payload_1.arg);\n                });\n            }\n            else if (type === 'async-work-execute') {\n                handleAfterLoad.call(this, e, function () {\n                    _this.napiModule.executeAsyncWork(payload_1.work);\n                });\n            }\n        }\n    };\n    return MessageHandler;\n}());\nfunction handleAfterLoad(e, f) {\n    if (this.instance !== undefined) {\n        f.call(this, e);\n    }\n    else {\n        this.messagesBeforeLoad.push(e.data);\n    }\n}\nfunction onLoaded(source) {\n    if (source == null) {\n        throw new TypeError('onLoad should return an object');\n    }\n    var instance = source.instance;\n    var napiModule = source.napiModule;\n    if (!instance)\n        throw new TypeError('onLoad should return an object which includes \"instance\"');\n    if (!napiModule)\n        throw new TypeError('onLoad should return an object which includes \"napiModule\"');\n    if (!napiModule.childThread)\n        throw new Error('napiModule should be created with `childThread: true`');\n    this.instance = instance;\n    this.napiModule = napiModule;\n    var postMessage = napiModule.postMessage;\n    postMessage({\n        __emnapi__: {\n            type: 'loaded',\n            payload: {}\n        }\n    });\n    var messages = this.messagesBeforeLoad;\n    this.messagesBeforeLoad = [];\n    for (var i = 0; i < messages.length; i++) {\n        var data = messages[i];\n        this.handle({ data: data });\n    }\n}\n\nvar version = \"1.1.1\";\n\nexport { MessageHandler, createNapiModule, instantiateNapiModule, instantiateNapiModuleSync, loadNapiModule, loadNapiModuleSync, version };\n","/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n  return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose;\n    if (async) {\n        if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n        dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n        if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n        dispose = value[Symbol.dispose];\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  function next() {\n    while (env.stack.length) {\n      var rec = env.stack.pop();\n      try {\n        var result = rec.dispose && rec.dispose.call(rec.value);\n        if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n      }\n      catch (e) {\n          fail(e);\n      }\n    }\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n};\n","import { __extends } from 'tslib';\n\nvar EMPTY_ARGS = [];\nvar CallbackInfo = /*#__PURE__*/ (function () {\n    function CallbackInfo(id, parent, child, thiz, data, args, fn) {\n        this.id = id;\n        this.parent = parent;\n        this.child = child;\n        this.thiz = thiz;\n        this.data = data;\n        this.args = args;\n        this.fn = fn;\n    }\n    CallbackInfo.prototype.getNewTarget = function (envObject) {\n        var thiz = this.thiz;\n        // eslint-disable-next-line @typescript-eslint/prefer-optional-chain\n        if (thiz == null || thiz.constructor == null)\n            return 0;\n        return thiz instanceof this.fn ? envObject.ensureHandleId(thiz.constructor) : 0;\n    };\n    CallbackInfo.prototype.dispose = function () {\n        if (this.thiz !== undefined)\n            this.thiz = undefined;\n        this.args = EMPTY_ARGS;\n        this.fn = null;\n    };\n    return CallbackInfo;\n}());\nvar ROOT_CBINFO = new CallbackInfo(0, null, null, null, 0, null, null);\nvar CallbackInfoStack = /*#__PURE__*/ (function () {\n    function CallbackInfoStack() {\n        this.current = ROOT_CBINFO;\n    }\n    CallbackInfoStack.prototype.get = function (id) {\n        if (id === 1)\n            return ROOT_CBINFO.child;\n        var info = ROOT_CBINFO;\n        for (var i = 0; i < id; ++i) {\n            info = info.child;\n            if (info === null)\n                return null;\n        }\n        return info === ROOT_CBINFO ? null : info;\n    };\n    CallbackInfoStack.prototype.pop = function () {\n        var current = this.current;\n        if (current === ROOT_CBINFO)\n            return;\n        this.current = current.parent;\n        current.dispose();\n    };\n    CallbackInfoStack.prototype.push = function (thiz, data, args, fn) {\n        var info = this.current.child;\n        if (info) {\n            info.thiz = thiz;\n            info.data = data;\n            info.args = args;\n            info.fn = fn;\n        }\n        else {\n            info = new CallbackInfo(this.current.id + 1, this.current, null, thiz, data, args, fn);\n            this.current.child = info;\n        }\n        this.current = info;\n        return info.id;\n    };\n    CallbackInfoStack.prototype.dispose = function () {\n        this.current = null;\n    };\n    return CallbackInfoStack;\n}());\n\nvar supportNewFunction = /*#__PURE__*/ (function () {\n    var f;\n    try {\n        f = new Function();\n    }\n    catch (_) {\n        return false;\n    }\n    return typeof f === 'function';\n})();\nvar _global = /*#__PURE__*/ (function () {\n    if (typeof globalThis !== 'undefined')\n        return globalThis;\n    var g = (function () { return this; })();\n    if (!g && supportNewFunction) {\n        try {\n            g = new Function('return this')();\n        }\n        catch (_) { }\n    }\n    if (!g) {\n        if (typeof __webpack_public_path__ === 'undefined') {\n            if (typeof global !== 'undefined')\n                return global;\n        }\n        if (typeof window !== 'undefined')\n            return window;\n        if (typeof self !== 'undefined')\n            return self;\n    }\n    return g;\n})();\nvar TryCatch = /*#__PURE__*/ (function () {\n    function TryCatch() {\n        this._exception = undefined;\n        this._caught = false;\n    }\n    TryCatch.prototype.isEmpty = function () {\n        return !this._caught;\n    };\n    TryCatch.prototype.hasCaught = function () {\n        return this._caught;\n    };\n    TryCatch.prototype.exception = function () {\n        return this._exception;\n    };\n    TryCatch.prototype.setError = function (err) {\n        this._caught = true;\n        this._exception = err;\n    };\n    TryCatch.prototype.reset = function () {\n        this._caught = false;\n        this._exception = undefined;\n    };\n    TryCatch.prototype.extractException = function () {\n        var e = this._exception;\n        this.reset();\n        return e;\n    };\n    return TryCatch;\n}());\nvar canSetFunctionName = /*#__PURE__*/ (function () {\n    var _a;\n    try {\n        return Boolean((_a = Object.getOwnPropertyDescriptor(Function.prototype, 'name')) === null || _a === void 0 ? void 0 : _a.configurable);\n    }\n    catch (_) {\n        return false;\n    }\n})();\nvar supportReflect = typeof Reflect === 'object';\nvar supportFinalizer = (typeof FinalizationRegistry !== 'undefined') && (typeof WeakRef !== 'undefined');\nvar supportWeakSymbol = /*#__PURE__*/ (function () {\n    try {\n        // eslint-disable-next-line symbol-description\n        var sym = Symbol();\n        // eslint-disable-next-line no-new\n        new WeakRef(sym);\n        new WeakMap().set(sym, undefined);\n    }\n    catch (_) {\n        return false;\n    }\n    return true;\n})();\nvar supportBigInt = typeof BigInt !== 'undefined';\nfunction isReferenceType(v) {\n    return (typeof v === 'object' && v !== null) || typeof v === 'function';\n}\nvar _require = /*#__PURE__*/ (function () {\n    var nativeRequire;\n    if (typeof __webpack_public_path__ !== 'undefined') {\n        nativeRequire = (function () {\n            return typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : undefined;\n        })();\n    }\n    else {\n        nativeRequire = (function () {\n            return typeof __webpack_public_path__ !== 'undefined' ? (typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : undefined) : (typeof require !== 'undefined' ? require : undefined);\n        })();\n    }\n    return nativeRequire;\n})();\nvar _MessageChannel = typeof MessageChannel === 'function'\n    ? MessageChannel\n    : /*#__PURE__*/ (function () {\n        try {\n            return _require('worker_threads').MessageChannel;\n        }\n        catch (_) { }\n        return undefined;\n    })();\nvar _setImmediate = typeof setImmediate === 'function'\n    ? setImmediate\n    : function (callback) {\n        if (typeof callback !== 'function') {\n            throw new TypeError('The \"callback\" argument must be of type function');\n        }\n        if (_MessageChannel) {\n            var channel_1 = new _MessageChannel();\n            channel_1.port1.onmessage = function () {\n                channel_1.port1.onmessage = null;\n                channel_1 = undefined;\n                callback();\n            };\n            channel_1.port2.postMessage(null);\n        }\n        else {\n            setTimeout(callback, 0);\n        }\n    };\nvar _Buffer = typeof Buffer === 'function'\n    ? Buffer\n    : /*#__PURE__*/ (function () {\n        try {\n            return _require('buffer').Buffer;\n        }\n        catch (_) { }\n        return undefined;\n    })();\nvar version = \"1.1.1\";\nvar NODE_API_SUPPORTED_VERSION_MIN = 1 /* Version.NODE_API_SUPPORTED_VERSION_MIN */;\nvar NODE_API_SUPPORTED_VERSION_MAX = 9 /* Version.NODE_API_SUPPORTED_VERSION_MAX */;\nvar NAPI_VERSION_EXPERIMENTAL = 2147483647 /* Version.NAPI_VERSION_EXPERIMENTAL */;\nvar NODE_API_DEFAULT_MODULE_API_VERSION = 8 /* Version.NODE_API_DEFAULT_MODULE_API_VERSION */;\n\nvar Handle = /*#__PURE__*/ (function () {\n    function Handle(id, value) {\n        this.id = id;\n        this.value = value;\n    }\n    Handle.prototype.data = function (envObject) {\n        return envObject.getObjectBinding(this.value).data;\n    };\n    Handle.prototype.isNumber = function () {\n        return typeof this.value === 'number';\n    };\n    Handle.prototype.isBigInt = function () {\n        return typeof this.value === 'bigint';\n    };\n    Handle.prototype.isString = function () {\n        return typeof this.value === 'string';\n    };\n    Handle.prototype.isFunction = function () {\n        return typeof this.value === 'function';\n    };\n    Handle.prototype.isExternal = function () {\n        return (isReferenceType(this.value) && Object.getPrototypeOf(this.value) === null);\n    };\n    Handle.prototype.isObject = function () {\n        return typeof this.value === 'object' && this.value !== null;\n    };\n    Handle.prototype.isArray = function () {\n        return Array.isArray(this.value);\n    };\n    Handle.prototype.isArrayBuffer = function () {\n        return (this.value instanceof ArrayBuffer);\n    };\n    Handle.prototype.isTypedArray = function () {\n        return (ArrayBuffer.isView(this.value)) && !(this.value instanceof DataView);\n    };\n    Handle.prototype.isBuffer = function () {\n        return typeof _Buffer === 'function' && _Buffer.isBuffer(this.value);\n    };\n    Handle.prototype.isDataView = function () {\n        return (this.value instanceof DataView);\n    };\n    Handle.prototype.isDate = function () {\n        return (this.value instanceof Date);\n    };\n    Handle.prototype.isPromise = function () {\n        return (this.value instanceof Promise);\n    };\n    Handle.prototype.isBoolean = function () {\n        return typeof this.value === 'boolean';\n    };\n    Handle.prototype.isUndefined = function () {\n        return this.value === undefined;\n    };\n    Handle.prototype.isSymbol = function () {\n        return typeof this.value === 'symbol';\n    };\n    Handle.prototype.isNull = function () {\n        return this.value === null;\n    };\n    Handle.prototype.dispose = function () {\n        this.value = undefined;\n    };\n    return Handle;\n}());\nvar ConstHandle = /*#__PURE__*/ (function (_super) {\n    __extends(ConstHandle, _super);\n    function ConstHandle(id, value) {\n        return _super.call(this, id, value) || this;\n    }\n    ConstHandle.prototype.dispose = function () { };\n    return ConstHandle;\n}(Handle));\nfunction External() {\n    Object.setPrototypeOf(this, null);\n}\nExternal.prototype = null;\nvar HandleStore = /*#__PURE__*/ (function () {\n    function HandleStore() {\n        this._values = [\n            undefined,\n            HandleStore.UNDEFINED,\n            HandleStore.NULL,\n            HandleStore.FALSE,\n            HandleStore.TRUE,\n            HandleStore.GLOBAL\n        ];\n        this._next = HandleStore.MIN_ID;\n    }\n    HandleStore.prototype.push = function (value) {\n        var h;\n        var next = this._next;\n        var values = this._values;\n        if (next < values.length) {\n            h = values[next];\n            h.value = value;\n        }\n        else {\n            h = new Handle(next, value);\n            values[next] = h;\n        }\n        this._next++;\n        return h;\n    };\n    HandleStore.prototype.erase = function (start, end) {\n        this._next = start;\n        var values = this._values;\n        for (var i = start; i < end; ++i) {\n            values[i].dispose();\n        }\n    };\n    HandleStore.prototype.get = function (id) {\n        return this._values[id];\n    };\n    HandleStore.prototype.swap = function (a, b) {\n        var values = this._values;\n        var h = values[a];\n        values[a] = values[b];\n        values[a].id = Number(a);\n        values[b] = h;\n        h.id = Number(b);\n    };\n    HandleStore.prototype.dispose = function () {\n        this._values.length = HandleStore.MIN_ID;\n        this._next = HandleStore.MIN_ID;\n    };\n    HandleStore.UNDEFINED = new ConstHandle(1 /* GlobalHandle.UNDEFINED */, undefined);\n    HandleStore.NULL = new ConstHandle(2 /* GlobalHandle.NULL */, null);\n    HandleStore.FALSE = new ConstHandle(3 /* GlobalHandle.FALSE */, false);\n    HandleStore.TRUE = new ConstHandle(4 /* GlobalHandle.TRUE */, true);\n    HandleStore.GLOBAL = new ConstHandle(5 /* GlobalHandle.GLOBAL */, _global);\n    HandleStore.MIN_ID = 6;\n    return HandleStore;\n}());\n\nvar HandleScope = /*#__PURE__*/ (function () {\n    function HandleScope(handleStore, id, parentScope, start, end) {\n        if (end === void 0) { end = start; }\n        this.handleStore = handleStore;\n        this.id = id;\n        this.parent = parentScope;\n        this.child = null;\n        if (parentScope !== null)\n            parentScope.child = this;\n        this.start = start;\n        this.end = end;\n        this._escapeCalled = false;\n    }\n    HandleScope.prototype.add = function (value) {\n        var h = this.handleStore.push(value);\n        this.end++;\n        return h;\n    };\n    HandleScope.prototype.addExternal = function (envObject, data) {\n        var value = new External();\n        var h = envObject.ctx.handleStore.push(value);\n        var binding = envObject.initObjectBinding(value);\n        binding.data = data;\n        this.end++;\n        return h;\n    };\n    HandleScope.prototype.dispose = function () {\n        if (this.start === this.end)\n            return;\n        this.handleStore.erase(this.start, this.end);\n    };\n    HandleScope.prototype.escape = function (handle) {\n        if (this._escapeCalled)\n            return null;\n        this._escapeCalled = true;\n        if (handle < this.start || handle >= this.end) {\n            return null;\n        }\n        this.handleStore.swap(handle, this.start);\n        var h = this.handleStore.get(this.start);\n        this.start++;\n        this.parent.end++;\n        return h;\n    };\n    HandleScope.prototype.escapeCalled = function () {\n        return this._escapeCalled;\n    };\n    return HandleScope;\n}());\n\nvar ScopeStore = /*#__PURE__*/ (function () {\n    function ScopeStore() {\n        this._rootScope = new HandleScope(null, 0, null, 1, HandleStore.MIN_ID);\n        this.currentScope = this._rootScope;\n    }\n    ScopeStore.prototype.get = function (id) {\n        id = Number(id);\n        var scope = this.currentScope;\n        while (scope !== this._rootScope) {\n            if (scope.id === id) {\n                return scope;\n            }\n            scope = scope.parent;\n        }\n        return undefined;\n    };\n    ScopeStore.prototype.openScope = function (envObject) {\n        var currentScope = this.currentScope;\n        var scope = currentScope.child;\n        if (scope !== null) {\n            scope.start = scope.end = currentScope.end;\n            scope._escapeCalled = false;\n        }\n        else {\n            scope = new HandleScope(envObject.ctx.handleStore, currentScope.id + 1, currentScope, currentScope.end);\n        }\n        this.currentScope = scope;\n        envObject.openHandleScopes++;\n        return scope;\n    };\n    ScopeStore.prototype.closeScope = function (envObject) {\n        if (envObject.openHandleScopes === 0)\n            return;\n        var scope = this.currentScope;\n        this.currentScope = scope.parent;\n        scope.dispose();\n        envObject.openHandleScopes--;\n    };\n    ScopeStore.prototype.dispose = function () {\n        var scope = this.currentScope;\n        while (scope !== null) {\n            scope.handleStore = null;\n            scope.id = 0;\n            scope.parent = null;\n            scope.start = HandleStore.MIN_ID;\n            scope.end = HandleStore.MIN_ID;\n            scope._escapeCalled = false;\n            var child = scope.child;\n            scope.child = null;\n            scope = child;\n        }\n        this.currentScope = null;\n    };\n    return ScopeStore;\n}());\n\nvar RefTracker = /*#__PURE__*/ (function () {\n    function RefTracker() {\n        this._next = null;\n        this._prev = null;\n    }\n    /** @virtual */\n    RefTracker.prototype.finalize = function () { };\n    RefTracker.prototype.link = function (list) {\n        this._prev = list;\n        this._next = list._next;\n        if (this._next !== null) {\n            this._next._prev = this;\n        }\n        list._next = this;\n    };\n    RefTracker.prototype.unlink = function () {\n        if (this._prev !== null) {\n            this._prev._next = this._next;\n        }\n        if (this._next !== null) {\n            this._next._prev = this._prev;\n        }\n        this._prev = null;\n        this._next = null;\n    };\n    RefTracker.finalizeAll = function (list) {\n        while (list._next !== null) {\n            list._next.finalize();\n        }\n    };\n    return RefTracker;\n}());\n\nvar Finalizer = /*#__PURE__*/ (function () {\n    function Finalizer(envObject, _finalizeCallback, _finalizeData, _finalizeHint) {\n        if (_finalizeCallback === void 0) { _finalizeCallback = 0; }\n        if (_finalizeData === void 0) { _finalizeData = 0; }\n        if (_finalizeHint === void 0) { _finalizeHint = 0; }\n        this.envObject = envObject;\n        this._finalizeCallback = _finalizeCallback;\n        this._finalizeData = _finalizeData;\n        this._finalizeHint = _finalizeHint;\n    }\n    Finalizer.prototype.callback = function () { return this._finalizeCallback; };\n    Finalizer.prototype.data = function () { return this._finalizeData; };\n    Finalizer.prototype.hint = function () { return this._finalizeHint; };\n    Finalizer.prototype.resetFinalizer = function () {\n        this._finalizeCallback = 0;\n        this._finalizeData = 0;\n        this._finalizeHint = 0;\n    };\n    Finalizer.prototype.dispose = function () {\n        this.envObject = undefined;\n    };\n    return Finalizer;\n}());\n\nvar TrackedFinalizer = /*#__PURE__*/ (function (_super) {\n    __extends(TrackedFinalizer, _super);\n    function TrackedFinalizer(envObject, finalize_callback, finalize_data, finalize_hint) {\n        var _this = _super.call(this, envObject, finalize_callback, finalize_data, finalize_hint) || this;\n        _this._next = null;\n        _this._prev = null;\n        _this.link(!finalize_callback ? envObject.reflist : envObject.finalizing_reflist);\n        return _this;\n    }\n    TrackedFinalizer.finalizeAll = function (list) {\n        RefTracker.finalizeAll(list);\n    };\n    TrackedFinalizer.prototype.link = function (list) {\n        RefTracker.prototype.link.call(this, list);\n    };\n    TrackedFinalizer.prototype.unlink = function () {\n        RefTracker.prototype.unlink.call(this);\n    };\n    TrackedFinalizer.create = function (envObject, finalize_callback, finalize_data, finalize_hint) {\n        return new TrackedFinalizer(envObject, finalize_callback, finalize_data, finalize_hint);\n    };\n    TrackedFinalizer.prototype.dispose = function () {\n        this.unlink();\n        this.envObject.dequeueFinalizer(this);\n        _super.prototype.dispose.call(this);\n    };\n    TrackedFinalizer.prototype.finalize = function () {\n        this.finalizeCore(true);\n    };\n    TrackedFinalizer.prototype.finalizeCore = function (deleteMe) {\n        var finalize_callback = this._finalizeCallback;\n        var finalize_data = this._finalizeData;\n        var finalize_hint = this._finalizeHint;\n        this.resetFinalizer();\n        this.unlink();\n        var error;\n        var caught = false;\n        if (finalize_callback) {\n            var fini = Number(finalize_callback);\n            try {\n                this.envObject.callFinalizer(fini, finalize_data, finalize_hint);\n            }\n            catch (err) {\n                caught = true;\n                error = err;\n            }\n        }\n        if (deleteMe) {\n            this.dispose();\n        }\n        if (caught) {\n            throw error;\n        }\n    };\n    return TrackedFinalizer;\n}(Finalizer));\n\nvar RefBase = /*#__PURE__*/ (function (_super) {\n    __extends(RefBase, _super);\n    function RefBase(envObject, initial_refcount, ownership, finalize_callback, finalize_data, finalize_hint) {\n        var _this = _super.call(this, envObject, finalize_callback, finalize_data, finalize_hint) || this;\n        _this._refcount = initial_refcount;\n        _this._ownership = ownership;\n        return _this;\n    }\n    RefBase.prototype.data = function () {\n        return this._finalizeData;\n    };\n    RefBase.prototype.ref = function () {\n        return ++this._refcount;\n    };\n    RefBase.prototype.unref = function () {\n        if (this._refcount === 0) {\n            return 0;\n        }\n        return --this._refcount;\n    };\n    RefBase.prototype.refCount = function () {\n        return this._refcount;\n    };\n    RefBase.prototype.ownership = function () {\n        return this._ownership;\n    };\n    RefBase.prototype.finalize = function () {\n        this.finalizeCore(this._ownership === 0 /* Ownership.kRuntime */);\n    };\n    return RefBase;\n}(TrackedFinalizer));\n\nfunction throwNodeApiVersionError(moduleName, moduleApiVersion) {\n    var errorMessage = \"\".concat(moduleName, \" requires Node-API version \").concat(moduleApiVersion, \", but this version of Node.js only supports version \").concat(NODE_API_SUPPORTED_VERSION_MAX, \" add-ons.\");\n    throw new Error(errorMessage);\n}\nfunction handleThrow(envObject, value) {\n    if (envObject.terminatedOrTerminating()) {\n        return;\n    }\n    throw value;\n}\nvar Env = /*#__PURE__*/ (function () {\n    function Env(ctx, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort) {\n        this.ctx = ctx;\n        this.moduleApiVersion = moduleApiVersion;\n        this.makeDynCall_vppp = makeDynCall_vppp;\n        this.makeDynCall_vp = makeDynCall_vp;\n        this.abort = abort;\n        this.openHandleScopes = 0;\n        this.instanceData = null;\n        this.tryCatch = new TryCatch();\n        this.refs = 1;\n        this.reflist = new RefTracker();\n        this.finalizing_reflist = new RefTracker();\n        this.pendingFinalizers = [];\n        this.lastError = {\n            errorCode: 0 /* napi_status.napi_ok */,\n            engineErrorCode: 0,\n            engineReserved: 0\n        };\n        this.inGcFinalizer = false;\n        this._bindingMap = new WeakMap();\n        this.id = 0;\n    }\n    /** @virtual */\n    Env.prototype.canCallIntoJs = function () {\n        return true;\n    };\n    Env.prototype.terminatedOrTerminating = function () {\n        return !this.canCallIntoJs();\n    };\n    Env.prototype.ref = function () {\n        this.refs++;\n    };\n    Env.prototype.unref = function () {\n        this.refs--;\n        if (this.refs === 0) {\n            this.dispose();\n        }\n    };\n    Env.prototype.ensureHandle = function (value) {\n        return this.ctx.ensureHandle(value);\n    };\n    Env.prototype.ensureHandleId = function (value) {\n        return this.ensureHandle(value).id;\n    };\n    Env.prototype.clearLastError = function () {\n        var lastError = this.lastError;\n        if (lastError.errorCode !== 0 /* napi_status.napi_ok */)\n            lastError.errorCode = 0 /* napi_status.napi_ok */;\n        if (lastError.engineErrorCode !== 0)\n            lastError.engineErrorCode = 0;\n        if (lastError.engineReserved !== 0)\n            lastError.engineReserved = 0;\n        return 0 /* napi_status.napi_ok */;\n    };\n    Env.prototype.setLastError = function (error_code, engine_error_code, engine_reserved) {\n        if (engine_error_code === void 0) { engine_error_code = 0; }\n        if (engine_reserved === void 0) { engine_reserved = 0; }\n        var lastError = this.lastError;\n        if (lastError.errorCode !== error_code)\n            lastError.errorCode = error_code;\n        if (lastError.engineErrorCode !== engine_error_code)\n            lastError.engineErrorCode = engine_error_code;\n        if (lastError.engineReserved !== engine_reserved)\n            lastError.engineReserved = engine_reserved;\n        return error_code;\n    };\n    Env.prototype.getReturnStatus = function () {\n        return !this.tryCatch.hasCaught() ? 0 /* napi_status.napi_ok */ : this.setLastError(10 /* napi_status.napi_pending_exception */);\n    };\n    Env.prototype.callIntoModule = function (fn, handleException) {\n        if (handleException === void 0) { handleException = handleThrow; }\n        var openHandleScopesBefore = this.openHandleScopes;\n        this.clearLastError();\n        var r = fn(this);\n        if (openHandleScopesBefore !== this.openHandleScopes) {\n            this.abort('open_handle_scopes != open_handle_scopes_before');\n        }\n        if (this.tryCatch.hasCaught()) {\n            var err = this.tryCatch.extractException();\n            handleException(this, err);\n        }\n        return r;\n    };\n    /** @virtual */\n    Env.prototype.callFinalizer = function (cb, data, hint) {\n        var f = this.makeDynCall_vppp(cb);\n        var env = this.id;\n        var scope = this.ctx.openScope(this);\n        try {\n            this.callIntoModule(function () { f(env, data, hint); });\n        }\n        finally {\n            this.ctx.closeScope(this, scope);\n        }\n    };\n    Env.prototype.invokeFinalizerFromGC = function (finalizer) {\n        if (this.moduleApiVersion !== NAPI_VERSION_EXPERIMENTAL) {\n            this.enqueueFinalizer(finalizer);\n        }\n        else {\n            var saved = this.inGcFinalizer;\n            this.inGcFinalizer = true;\n            try {\n                finalizer.finalize();\n            }\n            finally {\n                this.inGcFinalizer = saved;\n            }\n        }\n    };\n    Env.prototype.checkGCAccess = function () {\n        if (this.moduleApiVersion === NAPI_VERSION_EXPERIMENTAL && this.inGcFinalizer) {\n            this.abort('Finalizer is calling a function that may affect GC state.\\n' +\n                'The finalizers are run directly from GC and must not affect GC ' +\n                'state.\\n' +\n                'Use `node_api_post_finalizer` from inside of the finalizer to work ' +\n                'around this issue.\\n' +\n                'It schedules the call as a new task in the event loop.');\n        }\n    };\n    /** @virtual */\n    Env.prototype.enqueueFinalizer = function (finalizer) {\n        if (this.pendingFinalizers.indexOf(finalizer) === -1) {\n            this.pendingFinalizers.push(finalizer);\n        }\n    };\n    /** @virtual */\n    Env.prototype.dequeueFinalizer = function (finalizer) {\n        var index = this.pendingFinalizers.indexOf(finalizer);\n        if (index !== -1) {\n            this.pendingFinalizers.splice(index, 1);\n        }\n    };\n    /** @virtual */\n    Env.prototype.deleteMe = function () {\n        RefBase.finalizeAll(this.finalizing_reflist);\n        RefBase.finalizeAll(this.reflist);\n        this.tryCatch.extractException();\n        this.ctx.envStore.remove(this.id);\n    };\n    Env.prototype.dispose = function () {\n        if (this.id === 0)\n            return;\n        this.deleteMe();\n        this.id = 0;\n    };\n    Env.prototype.initObjectBinding = function (value) {\n        var binding = {\n            wrapped: 0,\n            tag: null,\n            data: 0\n        };\n        this._bindingMap.set(value, binding);\n        return binding;\n    };\n    Env.prototype.getObjectBinding = function (value) {\n        if (this._bindingMap.has(value)) {\n            return this._bindingMap.get(value);\n        }\n        return this.initObjectBinding(value);\n    };\n    Env.prototype.setInstanceData = function (data, finalize_cb, finalize_hint) {\n        if (this.instanceData) {\n            this.instanceData.dispose();\n        }\n        this.instanceData = new RefBase(this, 0, 0 /* Ownership.kRuntime */, finalize_cb, data, finalize_hint);\n    };\n    Env.prototype.getInstanceData = function () {\n        return this.instanceData ? this.instanceData.data() : 0;\n    };\n    return Env;\n}());\nvar NodeEnv = /*#__PURE__*/ (function (_super) {\n    __extends(NodeEnv, _super);\n    function NodeEnv(ctx, filename, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort, nodeBinding) {\n        var _this = _super.call(this, ctx, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort) || this;\n        _this.filename = filename;\n        _this.nodeBinding = nodeBinding;\n        _this.destructing = false;\n        _this.finalizationScheduled = false;\n        return _this;\n    }\n    NodeEnv.prototype.deleteMe = function () {\n        this.destructing = true;\n        this.drainFinalizerQueue();\n        _super.prototype.deleteMe.call(this);\n    };\n    NodeEnv.prototype.canCallIntoJs = function () {\n        return _super.prototype.canCallIntoJs.call(this) && this.ctx.canCallIntoJs();\n    };\n    NodeEnv.prototype.triggerFatalException = function (err) {\n        if (this.nodeBinding) {\n            this.nodeBinding.napi.fatalException(err);\n        }\n        else {\n            if (typeof process === 'object' && process !== null && typeof process._fatalException === 'function') {\n                var handled = process._fatalException(err);\n                if (!handled) {\n                    console.error(err);\n                    process.exit(1);\n                }\n            }\n            else {\n                throw err;\n            }\n        }\n    };\n    NodeEnv.prototype.callbackIntoModule = function (enforceUncaughtExceptionPolicy, fn) {\n        return this.callIntoModule(fn, function (envObject, err) {\n            if (envObject.terminatedOrTerminating()) {\n                return;\n            }\n            var hasProcess = typeof process === 'object' && process !== null;\n            var hasForceFlag = hasProcess ? Boolean(process.execArgv && (process.execArgv.indexOf('--force-node-api-uncaught-exceptions-policy') !== -1)) : false;\n            if (envObject.moduleApiVersion < NAPI_VERSION_EXPERIMENTAL && !hasForceFlag && !enforceUncaughtExceptionPolicy) {\n                var warn = hasProcess && typeof process.emitWarning === 'function'\n                    ? process.emitWarning\n                    : function (warning, type, code) {\n                        if (warning instanceof Error) {\n                            console.warn(warning.toString());\n                        }\n                        else {\n                            var prefix = code ? \"[\".concat(code, \"] \") : '';\n                            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n                            console.warn(\"\".concat(prefix).concat(type || 'Warning', \": \").concat(warning));\n                        }\n                    };\n                warn('Uncaught N-API callback exception detected, please run node with option --force-node-api-uncaught-exceptions-policy=true to handle those exceptions properly.', 'DeprecationWarning', 'DEP0168');\n                return;\n            }\n            envObject.triggerFatalException(err);\n        });\n    };\n    NodeEnv.prototype.callFinalizer = function (cb, data, hint) {\n        this.callFinalizerInternal(1, cb, data, hint);\n    };\n    NodeEnv.prototype.callFinalizerInternal = function (forceUncaught, cb, data, hint) {\n        var f = this.makeDynCall_vppp(cb);\n        var env = this.id;\n        var scope = this.ctx.openScope(this);\n        try {\n            this.callbackIntoModule(Boolean(forceUncaught), function () { f(env, data, hint); });\n        }\n        finally {\n            this.ctx.closeScope(this, scope);\n        }\n    };\n    NodeEnv.prototype.enqueueFinalizer = function (finalizer) {\n        var _this = this;\n        _super.prototype.enqueueFinalizer.call(this, finalizer);\n        if (!this.finalizationScheduled && !this.destructing) {\n            this.finalizationScheduled = true;\n            this.ref();\n            _setImmediate(function () {\n                _this.finalizationScheduled = false;\n                _this.unref();\n                _this.drainFinalizerQueue();\n            });\n        }\n    };\n    NodeEnv.prototype.drainFinalizerQueue = function () {\n        while (this.pendingFinalizers.length > 0) {\n            var refTracker = this.pendingFinalizers.shift();\n            refTracker.finalize();\n        }\n    };\n    return NodeEnv;\n}(Env));\nfunction newEnv(ctx, filename, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort, nodeBinding) {\n    moduleApiVersion = typeof moduleApiVersion !== 'number' ? NODE_API_DEFAULT_MODULE_API_VERSION : moduleApiVersion;\n    // Validate module_api_version.\n    if (moduleApiVersion < NODE_API_DEFAULT_MODULE_API_VERSION) {\n        moduleApiVersion = NODE_API_DEFAULT_MODULE_API_VERSION;\n    }\n    else if (moduleApiVersion > NODE_API_SUPPORTED_VERSION_MAX && moduleApiVersion !== NAPI_VERSION_EXPERIMENTAL) {\n        throwNodeApiVersionError(filename, moduleApiVersion);\n    }\n    var env = new NodeEnv(ctx, filename, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort, nodeBinding);\n    ctx.envStore.add(env);\n    ctx.addCleanupHook(env, function () { env.unref(); }, 0);\n    return env;\n}\n\nvar EmnapiError = /*#__PURE__*/ (function (_super) {\n    __extends(EmnapiError, _super);\n    function EmnapiError(message) {\n        var _newTarget = this.constructor;\n        var _this = _super.call(this, message) || this;\n        var ErrorConstructor = _newTarget;\n        var proto = ErrorConstructor.prototype;\n        if (!(_this instanceof EmnapiError)) {\n            var setPrototypeOf = Object.setPrototypeOf;\n            if (typeof setPrototypeOf === 'function') {\n                setPrototypeOf.call(Object, _this, proto);\n            }\n            else {\n                // eslint-disable-next-line no-proto\n                _this.__proto__ = proto;\n            }\n            if (typeof Error.captureStackTrace === 'function') {\n                Error.captureStackTrace(_this, ErrorConstructor);\n            }\n        }\n        return _this;\n    }\n    return EmnapiError;\n}(Error));\nObject.defineProperty(EmnapiError.prototype, 'name', {\n    configurable: true,\n    writable: true,\n    value: 'EmnapiError'\n});\nvar NotSupportWeakRefError = /*#__PURE__*/ (function (_super) {\n    __extends(NotSupportWeakRefError, _super);\n    function NotSupportWeakRefError(api, message) {\n        return _super.call(this, \"\".concat(api, \": The current runtime does not support \\\"FinalizationRegistry\\\" and \\\"WeakRef\\\".\").concat(message ? \" \".concat(message) : '')) || this;\n    }\n    return NotSupportWeakRefError;\n}(EmnapiError));\nObject.defineProperty(NotSupportWeakRefError.prototype, 'name', {\n    configurable: true,\n    writable: true,\n    value: 'NotSupportWeakRefError'\n});\nvar NotSupportBufferError = /*#__PURE__*/ (function (_super) {\n    __extends(NotSupportBufferError, _super);\n    function NotSupportBufferError(api, message) {\n        return _super.call(this, \"\".concat(api, \": The current runtime does not support \\\"Buffer\\\". Consider using buffer polyfill to make sure `globalThis.Buffer` is defined.\").concat(message ? \" \".concat(message) : '')) || this;\n    }\n    return NotSupportBufferError;\n}(EmnapiError));\nObject.defineProperty(NotSupportBufferError.prototype, 'name', {\n    configurable: true,\n    writable: true,\n    value: 'NotSupportBufferError'\n});\n\nvar StrongRef = /*#__PURE__*/ (function () {\n    function StrongRef(value) {\n        this._value = value;\n    }\n    StrongRef.prototype.deref = function () {\n        return this._value;\n    };\n    StrongRef.prototype.dispose = function () {\n        this._value = undefined;\n    };\n    return StrongRef;\n}());\nvar Persistent = /*#__PURE__*/ (function () {\n    function Persistent(value) {\n        this._ref = new StrongRef(value);\n    }\n    Persistent.prototype.setWeak = function (param, callback) {\n        if (!supportFinalizer || this._ref === undefined || this._ref instanceof WeakRef)\n            return;\n        var value = this._ref.deref();\n        try {\n            Persistent._registry.register(value, this, this);\n            var weakRef = new WeakRef(value);\n            this._ref.dispose();\n            this._ref = weakRef;\n            this._param = param;\n            this._callback = callback;\n        }\n        catch (err) {\n            if (typeof value === 'symbol') ;\n            else {\n                throw err;\n            }\n        }\n    };\n    Persistent.prototype.clearWeak = function () {\n        if (!supportFinalizer || this._ref === undefined)\n            return;\n        if (this._ref instanceof WeakRef) {\n            try {\n                Persistent._registry.unregister(this);\n            }\n            catch (_) { }\n            this._param = undefined;\n            this._callback = undefined;\n            var value = this._ref.deref();\n            if (value === undefined) {\n                this._ref = value;\n            }\n            else {\n                this._ref = new StrongRef(value);\n            }\n        }\n    };\n    Persistent.prototype.reset = function () {\n        if (supportFinalizer) {\n            try {\n                Persistent._registry.unregister(this);\n            }\n            catch (_) { }\n        }\n        this._param = undefined;\n        this._callback = undefined;\n        if (this._ref instanceof StrongRef) {\n            this._ref.dispose();\n        }\n        this._ref = undefined;\n    };\n    Persistent.prototype.isEmpty = function () {\n        return this._ref === undefined;\n    };\n    Persistent.prototype.deref = function () {\n        if (this._ref === undefined)\n            return undefined;\n        return this._ref.deref();\n    };\n    Persistent._registry = supportFinalizer\n        ? new FinalizationRegistry(function (value) {\n            value._ref = undefined;\n            var callback = value._callback;\n            var param = value._param;\n            value._callback = undefined;\n            value._param = undefined;\n            if (typeof callback === 'function') {\n                callback(param);\n            }\n        })\n        : undefined;\n    return Persistent;\n}());\n\nfunction weakCallback(ref) {\n    ref.persistent.reset();\n    ref.envObject.invokeFinalizerFromGC(ref);\n}\nfunction canBeHeldWeakly(value) {\n    return value.isObject() || value.isFunction() || value.isSymbol();\n}\nvar Reference = /*#__PURE__*/ (function (_super) {\n    __extends(Reference, _super);\n    function Reference(envObject, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) {\n        if (finalize_callback === void 0) { finalize_callback = 0; }\n        if (finalize_data === void 0) { finalize_data = 0; }\n        if (finalize_hint === void 0) { finalize_hint = 0; }\n        var _this = _super.call(this, envObject, initialRefcount >>> 0, ownership, finalize_callback, finalize_data, finalize_hint) || this;\n        _this.id = 0;\n        return _this;\n    }\n    Reference.create = function (envObject, handle_id, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) {\n        if (finalize_callback === void 0) { finalize_callback = 0; }\n        if (finalize_data === void 0) { finalize_data = 0; }\n        if (finalize_hint === void 0) { finalize_hint = 0; }\n        var handle = envObject.ctx.handleStore.get(handle_id);\n        var ref = new Reference(envObject, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint);\n        envObject.ctx.refStore.add(ref);\n        ref.canBeWeak = canBeHeldWeakly(handle);\n        ref.persistent = new Persistent(handle.value);\n        if (initialRefcount === 0) {\n            ref._setWeak();\n        }\n        return ref;\n    };\n    Reference.prototype.ref = function () {\n        if (this.persistent.isEmpty()) {\n            return 0;\n        }\n        var count = _super.prototype.ref.call(this);\n        if (count === 1 && this.canBeWeak) {\n            this.persistent.clearWeak();\n        }\n        return count;\n    };\n    Reference.prototype.unref = function () {\n        if (this.persistent.isEmpty()) {\n            return 0;\n        }\n        var oldRefcount = this.refCount();\n        var refcount = _super.prototype.unref.call(this);\n        if (oldRefcount === 1 && refcount === 0) {\n            this._setWeak();\n        }\n        return refcount;\n    };\n    Reference.prototype.get = function () {\n        if (this.persistent.isEmpty()) {\n            return 0;\n        }\n        var obj = this.persistent.deref();\n        var handle = this.envObject.ensureHandle(obj);\n        return handle.id;\n    };\n    Reference.prototype._setWeak = function () {\n        if (this.canBeWeak) {\n            this.persistent.setWeak(this, weakCallback);\n        }\n        else {\n            this.persistent.reset();\n        }\n    };\n    Reference.prototype.finalize = function () {\n        this.persistent.reset();\n        _super.prototype.finalize.call(this);\n    };\n    Reference.prototype.dispose = function () {\n        if (this.id === 0)\n            return;\n        this.persistent.reset();\n        this.envObject.ctx.refStore.remove(this.id);\n        _super.prototype.dispose.call(this);\n        this.id = 0;\n    };\n    return Reference;\n}(RefBase));\n\nvar Deferred = /*#__PURE__*/ (function () {\n    function Deferred(ctx, value) {\n        this.id = 0;\n        this.ctx = ctx;\n        this.value = value;\n    }\n    Deferred.create = function (ctx, value) {\n        var deferred = new Deferred(ctx, value);\n        ctx.deferredStore.add(deferred);\n        return deferred;\n    };\n    Deferred.prototype.resolve = function (value) {\n        this.value.resolve(value);\n        this.dispose();\n    };\n    Deferred.prototype.reject = function (reason) {\n        this.value.reject(reason);\n        this.dispose();\n    };\n    Deferred.prototype.dispose = function () {\n        this.ctx.deferredStore.remove(this.id);\n        this.id = 0;\n        this.value = null;\n        this.ctx = null;\n    };\n    return Deferred;\n}());\n\nvar Store = /*#__PURE__*/ (function () {\n    function Store() {\n        this._values = [undefined];\n        this._values.length = 4;\n        this._size = 1;\n        this._freeList = [];\n    }\n    Store.prototype.add = function (value) {\n        var id;\n        if (this._freeList.length) {\n            id = this._freeList.shift();\n        }\n        else {\n            id = this._size;\n            this._size++;\n            var capacity = this._values.length;\n            if (id >= capacity) {\n                this._values.length = capacity + (capacity >> 1) + 16;\n            }\n        }\n        value.id = id;\n        this._values[id] = value;\n    };\n    Store.prototype.get = function (id) {\n        return this._values[id];\n    };\n    Store.prototype.has = function (id) {\n        return this._values[id] !== undefined;\n    };\n    Store.prototype.remove = function (id) {\n        var value = this._values[id];\n        if (value) {\n            value.id = 0;\n            this._values[id] = undefined;\n            this._freeList.push(Number(id));\n        }\n    };\n    Store.prototype.dispose = function () {\n        for (var i = 1; i < this._size; ++i) {\n            var value = this._values[i];\n            value === null || value === void 0 ? void 0 : value.dispose();\n        }\n        this._values = [undefined];\n        this._size = 1;\n        this._freeList = [];\n    };\n    return Store;\n}());\n\nvar CleanupHookCallback = /*#__PURE__*/ (function () {\n    function CleanupHookCallback(envObject, fn, arg, order) {\n        this.envObject = envObject;\n        this.fn = fn;\n        this.arg = arg;\n        this.order = order;\n    }\n    return CleanupHookCallback;\n}());\nvar CleanupQueue = /*#__PURE__*/ (function () {\n    function CleanupQueue() {\n        this._cleanupHooks = [];\n        this._cleanupHookCounter = 0;\n    }\n    CleanupQueue.prototype.empty = function () {\n        return this._cleanupHooks.length === 0;\n    };\n    CleanupQueue.prototype.add = function (envObject, fn, arg) {\n        if (this._cleanupHooks.filter(function (hook) { return (hook.envObject === envObject && hook.fn === fn && hook.arg === arg); }).length > 0) {\n            throw new Error('Can not add same fn and arg twice');\n        }\n        this._cleanupHooks.push(new CleanupHookCallback(envObject, fn, arg, this._cleanupHookCounter++));\n    };\n    CleanupQueue.prototype.remove = function (envObject, fn, arg) {\n        for (var i = 0; i < this._cleanupHooks.length; ++i) {\n            var hook = this._cleanupHooks[i];\n            if (hook.envObject === envObject && hook.fn === fn && hook.arg === arg) {\n                this._cleanupHooks.splice(i, 1);\n                return;\n            }\n        }\n    };\n    CleanupQueue.prototype.drain = function () {\n        var hooks = this._cleanupHooks.slice();\n        hooks.sort(function (a, b) { return (b.order - a.order); });\n        for (var i = 0; i < hooks.length; ++i) {\n            var cb = hooks[i];\n            if (typeof cb.fn === 'number') {\n                cb.envObject.makeDynCall_vp(cb.fn)(cb.arg);\n            }\n            else {\n                cb.fn(cb.arg);\n            }\n            this._cleanupHooks.splice(this._cleanupHooks.indexOf(cb), 1);\n        }\n    };\n    CleanupQueue.prototype.dispose = function () {\n        this._cleanupHooks.length = 0;\n        this._cleanupHookCounter = 0;\n    };\n    return CleanupQueue;\n}());\nvar NodejsWaitingRequestCounter = /*#__PURE__*/ (function () {\n    function NodejsWaitingRequestCounter() {\n        this.refHandle = new _MessageChannel().port1;\n        this.count = 0;\n    }\n    NodejsWaitingRequestCounter.prototype.increase = function () {\n        if (this.count === 0) {\n            this.refHandle.ref();\n        }\n        this.count++;\n    };\n    NodejsWaitingRequestCounter.prototype.decrease = function () {\n        if (this.count === 0)\n            return;\n        if (this.count === 1) {\n            this.refHandle.unref();\n        }\n        this.count--;\n    };\n    return NodejsWaitingRequestCounter;\n}());\nvar Context = /*#__PURE__*/ (function () {\n    function Context() {\n        var _this = this;\n        this._isStopping = false;\n        this._canCallIntoJs = true;\n        this.envStore = new Store();\n        this.scopeStore = new ScopeStore();\n        this.refStore = new Store();\n        this.deferredStore = new Store();\n        this.handleStore = new HandleStore();\n        this.cbinfoStack = new CallbackInfoStack();\n        this.feature = {\n            supportReflect: supportReflect,\n            supportFinalizer: supportFinalizer,\n            supportWeakSymbol: supportWeakSymbol,\n            supportBigInt: supportBigInt,\n            supportNewFunction: supportNewFunction,\n            canSetFunctionName: canSetFunctionName,\n            setImmediate: _setImmediate,\n            Buffer: _Buffer,\n            MessageChannel: _MessageChannel\n        };\n        this.cleanupQueue = new CleanupQueue();\n        if (typeof process === 'object' && process !== null && typeof process.once === 'function') {\n            this.refCounter = new NodejsWaitingRequestCounter();\n            process.once('beforeExit', function () {\n                _this.destroy();\n            });\n        }\n    }\n    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n    Context.prototype.getRuntimeVersions = function () {\n        return {\n            version: version,\n            NODE_API_SUPPORTED_VERSION_MAX: NODE_API_SUPPORTED_VERSION_MAX,\n            NAPI_VERSION_EXPERIMENTAL: NAPI_VERSION_EXPERIMENTAL,\n            NODE_API_DEFAULT_MODULE_API_VERSION: NODE_API_DEFAULT_MODULE_API_VERSION\n        };\n    };\n    Context.prototype.createNotSupportWeakRefError = function (api, message) {\n        return new NotSupportWeakRefError(api, message);\n    };\n    Context.prototype.createNotSupportBufferError = function (api, message) {\n        return new NotSupportBufferError(api, message);\n    };\n    Context.prototype.createReference = function (envObject, handle_id, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) {\n        if (finalize_callback === void 0) { finalize_callback = 0; }\n        if (finalize_data === void 0) { finalize_data = 0; }\n        if (finalize_hint === void 0) { finalize_hint = 0; }\n        return Reference.create(envObject, handle_id, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint);\n    };\n    Context.prototype.createDeferred = function (value) {\n        return Deferred.create(this, value);\n    };\n    Context.prototype.createEnv = function (filename, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort, nodeBinding) {\n        return newEnv(this, filename, moduleApiVersion, makeDynCall_vppp, makeDynCall_vp, abort, nodeBinding);\n    };\n    Context.prototype.createTrackedFinalizer = function (envObject, finalize_callback, finalize_data, finalize_hint) {\n        return TrackedFinalizer.create(envObject, finalize_callback, finalize_data, finalize_hint);\n    };\n    Context.prototype.getCurrentScope = function () {\n        return this.scopeStore.currentScope;\n    };\n    Context.prototype.addToCurrentScope = function (value) {\n        return this.scopeStore.currentScope.add(value);\n    };\n    Context.prototype.openScope = function (envObject) {\n        return this.scopeStore.openScope(envObject);\n    };\n    Context.prototype.closeScope = function (envObject, _scope) {\n        this.scopeStore.closeScope(envObject);\n    };\n    Context.prototype.ensureHandle = function (value) {\n        switch (value) {\n            case undefined: return HandleStore.UNDEFINED;\n            case null: return HandleStore.NULL;\n            case true: return HandleStore.TRUE;\n            case false: return HandleStore.FALSE;\n            case _global: return HandleStore.GLOBAL;\n        }\n        return this.addToCurrentScope(value);\n    };\n    Context.prototype.addCleanupHook = function (envObject, fn, arg) {\n        this.cleanupQueue.add(envObject, fn, arg);\n    };\n    Context.prototype.removeCleanupHook = function (envObject, fn, arg) {\n        this.cleanupQueue.remove(envObject, fn, arg);\n    };\n    Context.prototype.runCleanup = function () {\n        while (!this.cleanupQueue.empty()) {\n            this.cleanupQueue.drain();\n        }\n    };\n    Context.prototype.increaseWaitingRequestCounter = function () {\n        var _a;\n        (_a = this.refCounter) === null || _a === void 0 ? void 0 : _a.increase();\n    };\n    Context.prototype.decreaseWaitingRequestCounter = function () {\n        var _a;\n        (_a = this.refCounter) === null || _a === void 0 ? void 0 : _a.decrease();\n    };\n    Context.prototype.setCanCallIntoJs = function (value) {\n        this._canCallIntoJs = value;\n    };\n    Context.prototype.setStopping = function (value) {\n        this._isStopping = value;\n    };\n    Context.prototype.canCallIntoJs = function () {\n        return this._canCallIntoJs && !this._isStopping;\n    };\n    Context.prototype.destroy = function () {\n        this.setStopping(true);\n        this.setCanCallIntoJs(false);\n        this.runCleanup();\n    };\n    return Context;\n}());\nvar defaultContext;\nfunction createContext() {\n    return new Context();\n}\nfunction getDefaultContext() {\n    if (!defaultContext) {\n        defaultContext = createContext();\n    }\n    return defaultContext;\n}\n\nexport { CallbackInfo, CallbackInfoStack, ConstHandle, Context, Deferred, EmnapiError, Env, Finalizer, Handle, HandleScope, HandleStore, NAPI_VERSION_EXPERIMENTAL, NODE_API_DEFAULT_MODULE_API_VERSION, NODE_API_SUPPORTED_VERSION_MAX, NODE_API_SUPPORTED_VERSION_MIN, NodeEnv, NotSupportBufferError, NotSupportWeakRefError, Persistent, RefBase, RefTracker, Reference, ScopeStore, Store, TrackedFinalizer, TryCatch, createContext, getDefaultContext, isReferenceType, version };\n","const _WebAssembly = typeof WebAssembly !== 'undefined'\n    ? WebAssembly\n    : typeof WXWebAssembly !== 'undefined'\n        ? WXWebAssembly\n        : undefined;\nif (!_WebAssembly) {\n    throw new Error('WebAssembly is not supported in this environment');\n}\n\n/* eslint-disable spaced-comment */\n\nfunction validateObject(value, name) {\n    if (value === null || typeof value !== 'object') {\n        throw new TypeError(`${name} must be an object. Received ${value === null ? 'null' : typeof value}`);\n    }\n}\nfunction validateArray(value, name) {\n    if (!Array.isArray(value)) {\n        throw new TypeError(`${name} must be an array. Received ${value === null ? 'null' : typeof value}`);\n    }\n}\nfunction validateBoolean(value, name) {\n    if (typeof value !== 'boolean') {\n        throw new TypeError(`${name} must be a boolean. Received ${value === null ? 'null' : typeof value}`);\n    }\n}\nfunction validateString(value, name) {\n    if (typeof value !== 'string') {\n        throw new TypeError(`${name} must be a string. Received ${value === null ? 'null' : typeof value}`);\n    }\n}\nfunction validateFunction(value, name) {\n    if (typeof value !== 'function') {\n        throw new TypeError(`${name} must be a function. Received ${value === null ? 'null' : typeof value}`);\n    }\n}\nfunction validateUndefined(value, name) {\n    if (value !== undefined) {\n        throw new TypeError(`${name} must be undefined. Received ${value === null ? 'null' : typeof value}`);\n    }\n}\nfunction isPromiseLike(obj) {\n    return !!(obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function');\n}\nfunction wrapInstanceExports(exports, mapFn) {\n    const newExports = Object.create(null);\n    Object.keys(exports).forEach(name => {\n        const exportValue = exports[name];\n        Object.defineProperty(newExports, name, {\n            enumerable: true,\n            value: mapFn(exportValue, name)\n        });\n    });\n    return newExports;\n}\nfunction sleepBreakIf(delay, breakIf) {\n    const start = Date.now();\n    const end = start + delay;\n    let ret = false;\n    while (Date.now() < end) {\n        if (breakIf()) {\n            ret = true;\n            break;\n        }\n    }\n    return ret;\n}\nfunction unsharedSlice(view, start, end) {\n    return ((typeof SharedArrayBuffer === 'function' && view.buffer instanceof SharedArrayBuffer) || (Object.prototype.toString.call(view.buffer.constructor) === '[object SharedArrayBuffer]'))\n        ? view.slice(start, end)\n        : view.subarray(start, end);\n}\n\nconst ignoreNames = [\n    'asyncify_get_state',\n    'asyncify_start_rewind',\n    'asyncify_start_unwind',\n    'asyncify_stop_rewind',\n    'asyncify_stop_unwind'\n];\nfunction tryAllocate(instance, wasm64, size, mallocName) {\n    if (typeof instance.exports[mallocName] !== 'function' || size <= 0) {\n        return {\n            wasm64,\n            dataPtr: 16,\n            start: wasm64 ? 32 : 24,\n            end: 1024\n        };\n    }\n    const malloc = instance.exports[mallocName];\n    const dataPtr = wasm64 ? Number(malloc(BigInt(16) + BigInt(size))) : malloc(8 + size);\n    if (dataPtr === 0) {\n        throw new Error('Allocate asyncify data failed');\n    }\n    return wasm64\n        ? { wasm64, dataPtr, start: dataPtr + 16, end: dataPtr + 16 + size }\n        : { wasm64, dataPtr, start: dataPtr + 8, end: dataPtr + 8 + size };\n}\n/** @public */\nclass Asyncify {\n    constructor() {\n        this.value = undefined;\n        this.exports = undefined;\n        this.dataPtr = 0;\n    }\n    init(memory, instance, options) {\n        var _a, _b;\n        if (this.exports) {\n            throw new Error('Asyncify has been initialized');\n        }\n        if (!(memory instanceof _WebAssembly.Memory)) {\n            throw new TypeError('Require WebAssembly.Memory object');\n        }\n        const exports = instance.exports;\n        for (let i = 0; i < ignoreNames.length; ++i) {\n            if (typeof exports[ignoreNames[i]] !== 'function') {\n                throw new TypeError('Invalid asyncify wasm');\n            }\n        }\n        let address;\n        const wasm64 = Boolean(options.wasm64);\n        if (!options.tryAllocate) {\n            address = {\n                wasm64,\n                dataPtr: 16,\n                start: wasm64 ? 32 : 24,\n                end: 1024\n            };\n        }\n        else {\n            if (options.tryAllocate === true) {\n                address = tryAllocate(instance, wasm64, 4096, 'malloc');\n            }\n            else {\n                address = tryAllocate(instance, wasm64, (_a = options.tryAllocate.size) !== null && _a !== void 0 ? _a : 4096, (_b = options.tryAllocate.name) !== null && _b !== void 0 ? _b : 'malloc');\n            }\n        }\n        this.dataPtr = address.dataPtr;\n        if (wasm64) {\n            new BigInt64Array(memory.buffer, this.dataPtr).set([BigInt(address.start), BigInt(address.end)]);\n        }\n        else {\n            new Int32Array(memory.buffer, this.dataPtr).set([address.start, address.end]);\n        }\n        this.exports = this.wrapExports(exports, options.wrapExports);\n        const asyncifiedInstance = Object.create(_WebAssembly.Instance.prototype);\n        Object.defineProperty(asyncifiedInstance, 'exports', { value: this.exports });\n        // Object.setPrototypeOf(instance, Instance.prototype)\n        return asyncifiedInstance;\n    }\n    assertState() {\n        if (this.exports.asyncify_get_state() !== 0 /* AsyncifyState.NONE */) {\n            throw new Error('Asyncify state error');\n        }\n    }\n    wrapImportFunction(f) {\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        const _this = this;\n        return (function () {\n            // eslint-disable-next-line no-unreachable-loop\n            while (_this.exports.asyncify_get_state() === 2 /* AsyncifyState.REWINDING */) {\n                _this.exports.asyncify_stop_rewind();\n                return _this.value;\n            }\n            _this.assertState();\n            const v = f.apply(this, arguments);\n            if (!isPromiseLike(v))\n                return v;\n            _this.exports.asyncify_start_unwind(_this.dataPtr);\n            _this.value = v;\n        });\n    }\n    wrapImports(imports) {\n        const importObject = {};\n        Object.keys(imports).forEach(k => {\n            const mod = imports[k];\n            const newModule = {};\n            Object.keys(mod).forEach(name => {\n                const importValue = mod[name];\n                if (typeof importValue === 'function') {\n                    newModule[name] = this.wrapImportFunction(importValue);\n                }\n                else {\n                    newModule[name] = importValue;\n                }\n            });\n            importObject[k] = newModule;\n        });\n        return importObject;\n    }\n    wrapExportFunction(f) {\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        const _this = this;\n        return (async function () {\n            _this.assertState();\n            let ret = f.apply(this, arguments);\n            while (_this.exports.asyncify_get_state() === 1 /* AsyncifyState.UNWINDING */) {\n                _this.exports.asyncify_stop_unwind();\n                _this.value = await _this.value;\n                _this.assertState();\n                _this.exports.asyncify_start_rewind(_this.dataPtr);\n                ret = f.call(this);\n            }\n            _this.assertState();\n            return ret;\n        });\n    }\n    wrapExports(exports, needWrap) {\n        return wrapInstanceExports(exports, (exportValue, name) => {\n            let ignore = ignoreNames.indexOf(name) !== -1 || typeof exportValue !== 'function';\n            if (Array.isArray(needWrap)) {\n                ignore = ignore || (needWrap.indexOf(name) === -1);\n            }\n            return ignore ? exportValue : this.wrapExportFunction(exportValue);\n        });\n    }\n}\n\nfunction validateImports(imports) {\n    if (imports && typeof imports !== 'object') {\n        throw new TypeError('imports must be an object or undefined');\n    }\n}\nfunction fetchWasm(urlOrBuffer, imports) {\n    if (typeof wx !== 'undefined' && typeof __wxConfig !== 'undefined') {\n        return _WebAssembly.instantiate(urlOrBuffer, imports);\n    }\n    return fetch(urlOrBuffer)\n        .then(response => response.arrayBuffer())\n        .then(buffer => _WebAssembly.instantiate(buffer, imports));\n}\n/** @public */\nfunction load(wasmInput, imports) {\n    validateImports(imports);\n    imports = imports !== null && imports !== void 0 ? imports : {};\n    let source;\n    if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) {\n        return _WebAssembly.instantiate(wasmInput, imports);\n    }\n    if (wasmInput instanceof _WebAssembly.Module) {\n        return _WebAssembly.instantiate(wasmInput, imports).then((instance) => {\n            return { instance, module: wasmInput };\n        });\n    }\n    if (typeof wasmInput !== 'string' && !(wasmInput instanceof URL)) {\n        throw new TypeError('Invalid source');\n    }\n    if (typeof _WebAssembly.instantiateStreaming === 'function') {\n        let responsePromise;\n        try {\n            responsePromise = fetch(wasmInput);\n            source = _WebAssembly.instantiateStreaming(responsePromise, imports).catch(() => {\n                return fetchWasm(wasmInput, imports);\n            });\n        }\n        catch (_) {\n            source = fetchWasm(wasmInput, imports);\n        }\n    }\n    else {\n        source = fetchWasm(wasmInput, imports);\n    }\n    return source;\n}\n/** @public */\nfunction asyncifyLoad(asyncify, urlOrBuffer, imports) {\n    validateImports(imports);\n    imports = imports !== null && imports !== void 0 ? imports : {};\n    const asyncifyHelper = new Asyncify();\n    imports = asyncifyHelper.wrapImports(imports);\n    return load(urlOrBuffer, imports).then(source => {\n        var _a;\n        const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);\n        return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };\n    });\n}\n/** @public */\nfunction loadSync(wasmInput, imports) {\n    validateImports(imports);\n    imports = imports !== null && imports !== void 0 ? imports : {};\n    let module;\n    if ((wasmInput instanceof ArrayBuffer) || ArrayBuffer.isView(wasmInput)) {\n        module = new _WebAssembly.Module(wasmInput);\n    }\n    else if (wasmInput instanceof WebAssembly.Module) {\n        module = wasmInput;\n    }\n    else {\n        throw new TypeError('Invalid source');\n    }\n    const instance = new _WebAssembly.Instance(module, imports);\n    const source = { instance, module };\n    return source;\n}\n/** @public */\nfunction asyncifyLoadSync(asyncify, buffer, imports) {\n    var _a;\n    validateImports(imports);\n    imports = imports !== null && imports !== void 0 ? imports : {};\n    const asyncifyHelper = new Asyncify();\n    imports = asyncifyHelper.wrapImports(imports);\n    const source = loadSync(buffer, imports);\n    const memory = source.instance.exports.memory || ((_a = imports.env) === null || _a === void 0 ? void 0 : _a.memory);\n    return { module: source.module, instance: asyncifyHelper.init(memory, source.instance, asyncify) };\n}\n\nconst CHAR_DOT = 46; /* . */\nconst CHAR_FORWARD_SLASH = 47; /* / */\nfunction isPosixPathSeparator(code) {\n    return code === CHAR_FORWARD_SLASH;\n}\nfunction normalizeString(path, allowAboveRoot, separator, isPathSeparator) {\n    let res = '';\n    let lastSegmentLength = 0;\n    let lastSlash = -1;\n    let dots = 0;\n    let code = 0;\n    for (let i = 0; i <= path.length; ++i) {\n        if (i < path.length) {\n            code = path.charCodeAt(i);\n        }\n        else if (isPathSeparator(code)) {\n            break;\n        }\n        else {\n            code = CHAR_FORWARD_SLASH;\n        }\n        if (isPathSeparator(code)) {\n            if (lastSlash === i - 1 || dots === 1) ;\n            else if (dots === 2) {\n                if (res.length < 2 || lastSegmentLength !== 2 ||\n                    res.charCodeAt(res.length - 1) !== CHAR_DOT ||\n                    res.charCodeAt(res.length - 2) !== CHAR_DOT) {\n                    if (res.length > 2) {\n                        const lastSlashIndex = res.indexOf(separator);\n                        if (lastSlashIndex === -1) {\n                            res = '';\n                            lastSegmentLength = 0;\n                        }\n                        else {\n                            res = res.slice(0, lastSlashIndex);\n                            lastSegmentLength =\n                                res.length - 1 - res.indexOf(separator);\n                        }\n                        lastSlash = i;\n                        dots = 0;\n                        continue;\n                    }\n                    else if (res.length !== 0) {\n                        res = '';\n                        lastSegmentLength = 0;\n                        lastSlash = i;\n                        dots = 0;\n                        continue;\n                    }\n                }\n                if (allowAboveRoot) {\n                    res += res.length > 0 ? `${separator}..` : '..';\n                    lastSegmentLength = 2;\n                }\n            }\n            else {\n                if (res.length > 0) {\n                    res += `${separator}${path.slice(lastSlash + 1, i)}`;\n                }\n                else {\n                    res = path.slice(lastSlash + 1, i);\n                }\n                lastSegmentLength = i - lastSlash - 1;\n            }\n            lastSlash = i;\n            dots = 0;\n        }\n        else if (code === CHAR_DOT && dots !== -1) {\n            ++dots;\n        }\n        else {\n            dots = -1;\n        }\n    }\n    return res;\n}\nfunction resolve(...args) {\n    let resolvedPath = '';\n    let resolvedAbsolute = false;\n    for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n        const path = i >= 0 ? args[i] : '/';\n        validateString(path, 'path');\n        // Skip empty entries\n        if (path.length === 0) {\n            continue;\n        }\n        resolvedPath = `${path}/${resolvedPath}`;\n        resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n    }\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n    // Normalize the path\n    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator);\n    if (resolvedAbsolute) {\n        return `/${resolvedPath}`;\n    }\n    return resolvedPath.length > 0 ? resolvedPath : '.';\n}\n\nconst FD_DATASYNC = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(0));\nconst FD_READ = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(1));\nconst FD_SEEK = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(2));\nconst FD_FDSTAT_SET_FLAGS = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(3));\nconst FD_SYNC = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(4));\nconst FD_TELL = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(5));\nconst FD_WRITE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(6));\nconst FD_ADVISE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(7));\nconst FD_ALLOCATE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(8));\nconst PATH_CREATE_DIRECTORY = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(9));\nconst PATH_CREATE_FILE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(10));\nconst PATH_LINK_SOURCE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(11));\nconst PATH_LINK_TARGET = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(12));\nconst PATH_OPEN = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(13));\nconst FD_READDIR = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(14));\nconst PATH_READLINK = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(15));\nconst PATH_RENAME_SOURCE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(16));\nconst PATH_RENAME_TARGET = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(17));\nconst PATH_FILESTAT_GET = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(18));\nconst PATH_FILESTAT_SET_SIZE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(19));\nconst PATH_FILESTAT_SET_TIMES = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(20));\nconst FD_FILESTAT_GET = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(21));\nconst FD_FILESTAT_SET_SIZE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(22));\nconst FD_FILESTAT_SET_TIMES = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(23));\nconst PATH_SYMLINK = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(24));\nconst PATH_REMOVE_DIRECTORY = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(25));\nconst PATH_UNLINK_FILE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(26));\nconst POLL_FD_READWRITE = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(27));\nconst SOCK_SHUTDOWN = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(28));\nconst SOCK_ACCEPT = ( /*#__PURE__*/BigInt(1) << /*#__PURE__*/ BigInt(29));\nconst WasiRights = {\n    FD_DATASYNC,\n    FD_READ,\n    FD_SEEK,\n    FD_FDSTAT_SET_FLAGS,\n    FD_SYNC,\n    FD_TELL,\n    FD_WRITE,\n    FD_ADVISE,\n    FD_ALLOCATE,\n    PATH_CREATE_DIRECTORY,\n    PATH_CREATE_FILE,\n    PATH_LINK_SOURCE,\n    PATH_LINK_TARGET,\n    PATH_OPEN,\n    FD_READDIR,\n    PATH_READLINK,\n    PATH_RENAME_SOURCE,\n    PATH_RENAME_TARGET,\n    PATH_FILESTAT_GET,\n    PATH_FILESTAT_SET_SIZE,\n    PATH_FILESTAT_SET_TIMES,\n    FD_FILESTAT_GET,\n    FD_FILESTAT_SET_SIZE,\n    FD_FILESTAT_SET_TIMES,\n    PATH_SYMLINK,\n    PATH_REMOVE_DIRECTORY,\n    PATH_UNLINK_FILE,\n    POLL_FD_READWRITE,\n    SOCK_SHUTDOWN,\n    SOCK_ACCEPT\n};\n\nfunction strerror(errno) {\n    switch (errno) {\n        case 0 /* WasiErrno.ESUCCESS */: return 'Success';\n        case 1 /* WasiErrno.E2BIG */: return 'Argument list too long';\n        case 2 /* WasiErrno.EACCES */: return 'Permission denied';\n        case 3 /* WasiErrno.EADDRINUSE */: return 'Address in use';\n        case 4 /* WasiErrno.EADDRNOTAVAIL */: return 'Address not available';\n        case 5 /* WasiErrno.EAFNOSUPPORT */: return 'Address family not supported by protocol';\n        case 6 /* WasiErrno.EAGAIN */: return 'Resource temporarily unavailable';\n        case 7 /* WasiErrno.EALREADY */: return 'Operation already in progress';\n        case 8 /* WasiErrno.EBADF */: return 'Bad file descriptor';\n        case 9 /* WasiErrno.EBADMSG */: return 'Bad message';\n        case 10 /* WasiErrno.EBUSY */: return 'Resource busy';\n        case 11 /* WasiErrno.ECANCELED */: return 'Operation canceled';\n        case 12 /* WasiErrno.ECHILD */: return 'No child process';\n        case 13 /* WasiErrno.ECONNABORTED */: return 'Connection aborted';\n        case 14 /* WasiErrno.ECONNREFUSED */: return 'Connection refused';\n        case 15 /* WasiErrno.ECONNRESET */: return 'Connection reset by peer';\n        case 16 /* WasiErrno.EDEADLK */: return 'Resource deadlock would occur';\n        case 17 /* WasiErrno.EDESTADDRREQ */: return 'Destination address required';\n        case 18 /* WasiErrno.EDOM */: return 'Domain error';\n        case 19 /* WasiErrno.EDQUOT */: return 'Quota exceeded';\n        case 20 /* WasiErrno.EEXIST */: return 'File exists';\n        case 21 /* WasiErrno.EFAULT */: return 'Bad address';\n        case 22 /* WasiErrno.EFBIG */: return 'File too large';\n        case 23 /* WasiErrno.EHOSTUNREACH */: return 'Host is unreachable';\n        case 24 /* WasiErrno.EIDRM */: return 'Identifier removed';\n        case 25 /* WasiErrno.EILSEQ */: return 'Illegal byte sequence';\n        case 26 /* WasiErrno.EINPROGRESS */: return 'Operation in progress';\n        case 27 /* WasiErrno.EINTR */: return 'Interrupted system call';\n        case 28 /* WasiErrno.EINVAL */: return 'Invalid argument';\n        case 29 /* WasiErrno.EIO */: return 'I/O error';\n        case 30 /* WasiErrno.EISCONN */: return 'Socket is connected';\n        case 31 /* WasiErrno.EISDIR */: return 'Is a directory';\n        case 32 /* WasiErrno.ELOOP */: return 'Symbolic link loop';\n        case 33 /* WasiErrno.EMFILE */: return 'No file descriptors available';\n        case 34 /* WasiErrno.EMLINK */: return 'Too many links';\n        case 35 /* WasiErrno.EMSGSIZE */: return 'Message too large';\n        case 36 /* WasiErrno.EMULTIHOP */: return 'Multihop attempted';\n        case 37 /* WasiErrno.ENAMETOOLONG */: return 'Filename too long';\n        case 38 /* WasiErrno.ENETDOWN */: return 'Network is down';\n        case 39 /* WasiErrno.ENETRESET */: return 'Connection reset by network';\n        case 40 /* WasiErrno.ENETUNREACH */: return 'Network unreachable';\n        case 41 /* WasiErrno.ENFILE */: return 'Too many files open in system';\n        case 42 /* WasiErrno.ENOBUFS */: return 'No buffer space available';\n        case 43 /* WasiErrno.ENODEV */: return 'No such device';\n        case 44 /* WasiErrno.ENOENT */: return 'No such file or directory';\n        case 45 /* WasiErrno.ENOEXEC */: return 'Exec format error';\n        case 46 /* WasiErrno.ENOLCK */: return 'No locks available';\n        case 47 /* WasiErrno.ENOLINK */: return 'Link has been severed';\n        case 48 /* WasiErrno.ENOMEM */: return 'Out of memory';\n        case 49 /* WasiErrno.ENOMSG */: return 'No message of the desired type';\n        case 50 /* WasiErrno.ENOPROTOOPT */: return 'Protocol not available';\n        case 51 /* WasiErrno.ENOSPC */: return 'No space left on device';\n        case 52 /* WasiErrno.ENOSYS */: return 'Function not implemented';\n        case 53 /* WasiErrno.ENOTCONN */: return 'Socket not connected';\n        case 54 /* WasiErrno.ENOTDIR */: return 'Not a directory';\n        case 55 /* WasiErrno.ENOTEMPTY */: return 'Directory not empty';\n        case 56 /* WasiErrno.ENOTRECOVERABLE */: return 'State not recoverable';\n        case 57 /* WasiErrno.ENOTSOCK */: return 'Not a socket';\n        case 58 /* WasiErrno.ENOTSUP */: return 'Not supported';\n        case 59 /* WasiErrno.ENOTTY */: return 'Not a tty';\n        case 60 /* WasiErrno.ENXIO */: return 'No such device or address';\n        case 61 /* WasiErrno.EOVERFLOW */: return 'Value too large for data type';\n        case 62 /* WasiErrno.EOWNERDEAD */: return 'Previous owner died';\n        case 63 /* WasiErrno.EPERM */: return 'Operation not permitted';\n        case 64 /* WasiErrno.EPIPE */: return 'Broken pipe';\n        case 65 /* WasiErrno.EPROTO */: return 'Protocol error';\n        case 66 /* WasiErrno.EPROTONOSUPPORT */: return 'Protocol not supported';\n        case 67 /* WasiErrno.EPROTOTYPE */: return 'Protocol wrong type for socket';\n        case 68 /* WasiErrno.ERANGE */: return 'Result not representable';\n        case 69 /* WasiErrno.EROFS */: return 'Read-only file system';\n        case 70 /* WasiErrno.ESPIPE */: return 'Invalid seek';\n        case 71 /* WasiErrno.ESRCH */: return 'No such process';\n        case 72 /* WasiErrno.ESTALE */: return 'Stale file handle';\n        case 73 /* WasiErrno.ETIMEDOUT */: return 'Operation timed out';\n        case 74 /* WasiErrno.ETXTBSY */: return 'Text file busy';\n        case 75 /* WasiErrno.EXDEV */: return 'Cross-device link';\n        case 76 /* WasiErrno.ENOTCAPABLE */: return 'Capabilities insufficient';\n        default: return 'Unknown error';\n    }\n}\nclass WasiError extends Error {\n    constructor(message, errno) {\n        super(message);\n        this.errno = errno;\n    }\n    getErrorMessage() {\n        return strerror(this.errno);\n    }\n}\nObject.defineProperty(WasiError.prototype, 'name', {\n    configurable: true,\n    writable: true,\n    value: 'WasiError'\n});\n\nconst RIGHTS_ALL = WasiRights.FD_DATASYNC |\n    WasiRights.FD_READ |\n    WasiRights.FD_SEEK |\n    WasiRights.FD_FDSTAT_SET_FLAGS |\n    WasiRights.FD_SYNC |\n    WasiRights.FD_TELL |\n    WasiRights.FD_WRITE |\n    WasiRights.FD_ADVISE |\n    WasiRights.FD_ALLOCATE |\n    WasiRights.PATH_CREATE_DIRECTORY |\n    WasiRights.PATH_CREATE_FILE |\n    WasiRights.PATH_LINK_SOURCE |\n    WasiRights.PATH_LINK_TARGET |\n    WasiRights.PATH_OPEN |\n    WasiRights.FD_READDIR |\n    WasiRights.PATH_READLINK |\n    WasiRights.PATH_RENAME_SOURCE |\n    WasiRights.PATH_RENAME_TARGET |\n    WasiRights.PATH_FILESTAT_GET |\n    WasiRights.PATH_FILESTAT_SET_SIZE |\n    WasiRights.PATH_FILESTAT_SET_TIMES |\n    WasiRights.FD_FILESTAT_GET |\n    WasiRights.FD_FILESTAT_SET_TIMES |\n    WasiRights.FD_FILESTAT_SET_SIZE |\n    WasiRights.PATH_SYMLINK |\n    WasiRights.PATH_UNLINK_FILE |\n    WasiRights.PATH_REMOVE_DIRECTORY |\n    WasiRights.POLL_FD_READWRITE |\n    WasiRights.SOCK_SHUTDOWN |\n    WasiRights.SOCK_ACCEPT;\nconst BLOCK_DEVICE_BASE = RIGHTS_ALL;\nconst BLOCK_DEVICE_INHERITING = RIGHTS_ALL;\nconst CHARACTER_DEVICE_BASE = RIGHTS_ALL;\nconst CHARACTER_DEVICE_INHERITING = RIGHTS_ALL;\nconst REGULAR_FILE_BASE = WasiRights.FD_DATASYNC |\n    WasiRights.FD_READ |\n    WasiRights.FD_SEEK |\n    WasiRights.FD_FDSTAT_SET_FLAGS |\n    WasiRights.FD_SYNC |\n    WasiRights.FD_TELL |\n    WasiRights.FD_WRITE |\n    WasiRights.FD_ADVISE |\n    WasiRights.FD_ALLOCATE |\n    WasiRights.FD_FILESTAT_GET |\n    WasiRights.FD_FILESTAT_SET_SIZE |\n    WasiRights.FD_FILESTAT_SET_TIMES |\n    WasiRights.POLL_FD_READWRITE;\nconst REGULAR_FILE_INHERITING = /*#__PURE__*/ BigInt(0);\nconst DIRECTORY_BASE = WasiRights.FD_FDSTAT_SET_FLAGS |\n    WasiRights.FD_SYNC |\n    WasiRights.FD_ADVISE |\n    WasiRights.PATH_CREATE_DIRECTORY |\n    WasiRights.PATH_CREATE_FILE |\n    WasiRights.PATH_LINK_SOURCE |\n    WasiRights.PATH_LINK_TARGET |\n    WasiRights.PATH_OPEN |\n    WasiRights.FD_READDIR |\n    WasiRights.PATH_READLINK |\n    WasiRights.PATH_RENAME_SOURCE |\n    WasiRights.PATH_RENAME_TARGET |\n    WasiRights.PATH_FILESTAT_GET |\n    WasiRights.PATH_FILESTAT_SET_SIZE |\n    WasiRights.PATH_FILESTAT_SET_TIMES |\n    WasiRights.FD_FILESTAT_GET |\n    WasiRights.FD_FILESTAT_SET_TIMES |\n    WasiRights.PATH_SYMLINK |\n    WasiRights.PATH_UNLINK_FILE |\n    WasiRights.PATH_REMOVE_DIRECTORY |\n    WasiRights.POLL_FD_READWRITE;\nconst DIRECTORY_INHERITING = DIRECTORY_BASE | REGULAR_FILE_BASE;\nconst SOCKET_BASE = (WasiRights.FD_READ |\n    WasiRights.FD_FDSTAT_SET_FLAGS |\n    WasiRights.FD_WRITE |\n    WasiRights.FD_FILESTAT_GET |\n    WasiRights.POLL_FD_READWRITE |\n    WasiRights.SOCK_SHUTDOWN);\nconst SOCKET_INHERITING = RIGHTS_ALL;\nconst TTY_BASE = WasiRights.FD_READ |\n    WasiRights.FD_FDSTAT_SET_FLAGS |\n    WasiRights.FD_WRITE |\n    WasiRights.FD_FILESTAT_GET |\n    WasiRights.POLL_FD_READWRITE;\nconst TTY_INHERITING = /*#__PURE__*/ BigInt(0);\nfunction getRights(stdio, fd, flags, type) {\n    const ret = {\n        base: BigInt(0),\n        inheriting: BigInt(0)\n    };\n    if (type === 0 /* WasiFileType.UNKNOWN */) {\n        throw new WasiError('Unknown file type', 28 /* WasiErrno.EINVAL */);\n    }\n    switch (type) {\n        case 4 /* WasiFileType.REGULAR_FILE */:\n            ret.base = REGULAR_FILE_BASE;\n            ret.inheriting = REGULAR_FILE_INHERITING;\n            break;\n        case 3 /* WasiFileType.DIRECTORY */:\n            ret.base = DIRECTORY_BASE;\n            ret.inheriting = DIRECTORY_INHERITING;\n            break;\n        case 6 /* WasiFileType.SOCKET_STREAM */:\n        case 5 /* WasiFileType.SOCKET_DGRAM */:\n            ret.base = SOCKET_BASE;\n            ret.inheriting = SOCKET_INHERITING;\n            break;\n        case 2 /* WasiFileType.CHARACTER_DEVICE */:\n            if (stdio.indexOf(fd) !== -1) {\n                ret.base = TTY_BASE;\n                ret.inheriting = TTY_INHERITING;\n            }\n            else {\n                ret.base = CHARACTER_DEVICE_BASE;\n                ret.inheriting = CHARACTER_DEVICE_INHERITING;\n            }\n            break;\n        case 1 /* WasiFileType.BLOCK_DEVICE */:\n            ret.base = BLOCK_DEVICE_BASE;\n            ret.inheriting = BLOCK_DEVICE_INHERITING;\n            break;\n        default:\n            ret.base = BigInt(0);\n            ret.inheriting = BigInt(0);\n    }\n    /* Disable read/write bits depending on access mode. */\n    const read_or_write_only = flags & (0 | 1 | 2);\n    if (read_or_write_only === 0) {\n        ret.base &= ~WasiRights.FD_WRITE;\n    }\n    else if (read_or_write_only === 1) {\n        ret.base &= ~WasiRights.FD_READ;\n    }\n    return ret;\n}\n\nfunction concatBuffer(buffers, size) {\n    let total = 0;\n    if (typeof size === 'number' && size >= 0) {\n        total = size;\n    }\n    else {\n        for (let i = 0; i < buffers.length; i++) {\n            const buffer = buffers[i];\n            total += buffer.length;\n        }\n    }\n    let pos = 0;\n    const ret = new Uint8Array(total);\n    for (let i = 0; i < buffers.length; i++) {\n        const buffer = buffers[i];\n        ret.set(buffer, pos);\n        pos += buffer.length;\n    }\n    return ret;\n}\nclass FileDescriptor {\n    constructor(id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen) {\n        this.id = id;\n        this.fd = fd;\n        this.path = path;\n        this.realPath = realPath;\n        this.type = type;\n        this.rightsBase = rightsBase;\n        this.rightsInheriting = rightsInheriting;\n        this.preopen = preopen;\n        this.pos = BigInt(0);\n        this.size = BigInt(0);\n    }\n    seek(offset, whence) {\n        if (whence === 0 /* WasiWhence.SET */) {\n            this.pos = BigInt(offset);\n        }\n        else if (whence === 1 /* WasiWhence.CUR */) {\n            this.pos += BigInt(offset);\n        }\n        else if (whence === 2 /* WasiWhence.END */) {\n            this.pos = BigInt(this.size) - BigInt(offset);\n        }\n        else {\n            throw new WasiError('Unknown whence', 29 /* WasiErrno.EIO */);\n        }\n        return this.pos;\n    }\n}\nclass StandardOutput extends FileDescriptor {\n    constructor(log, id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen) {\n        super(id, fd, path, realPath, type, rightsBase, rightsInheriting, preopen);\n        this._log = log;\n        this._buf = null;\n    }\n    write(buffer) {\n        const originalBuffer = buffer;\n        if (this._buf) {\n            buffer = concatBuffer([this._buf, buffer]);\n            this._buf = null;\n        }\n        if (buffer.indexOf(10) === -1) {\n            this._buf = buffer;\n            return originalBuffer.byteLength;\n        }\n        let written = 0;\n        let lastBegin = 0;\n        let index;\n        while ((index = buffer.indexOf(10, written)) !== -1) {\n            const str = new TextDecoder().decode(buffer.subarray(lastBegin, index));\n            this._log(str);\n            written += index - lastBegin + 1;\n            lastBegin = index + 1;\n        }\n        if (written < buffer.length) {\n            this._buf = buffer.slice(written);\n        }\n        return originalBuffer.byteLength;\n    }\n}\nfunction toFileType(stat) {\n    if (stat.isBlockDevice())\n        return 1 /* WasiFileType.BLOCK_DEVICE */;\n    if (stat.isCharacterDevice())\n        return 2 /* WasiFileType.CHARACTER_DEVICE */;\n    if (stat.isDirectory())\n        return 3 /* WasiFileType.DIRECTORY */;\n    if (stat.isSocket())\n        return 6 /* WasiFileType.SOCKET_STREAM */;\n    if (stat.isFile())\n        return 4 /* WasiFileType.REGULAR_FILE */;\n    if (stat.isSymbolicLink())\n        return 7 /* WasiFileType.SYMBOLIC_LINK */;\n    return 0 /* WasiFileType.UNKNOWN */;\n}\nfunction toFileStat(view, buf, stat) {\n    view.setBigUint64(buf, stat.dev, true);\n    view.setBigUint64(buf + 8, stat.ino, true);\n    view.setBigUint64(buf + 16, BigInt(toFileType(stat)), true);\n    view.setBigUint64(buf + 24, stat.nlink, true);\n    view.setBigUint64(buf + 32, stat.size, true);\n    view.setBigUint64(buf + 40, stat.atimeMs * BigInt(1000000), true);\n    view.setBigUint64(buf + 48, stat.mtimeMs * BigInt(1000000), true);\n    view.setBigUint64(buf + 56, stat.ctimeMs * BigInt(1000000), true);\n}\nclass FileDescriptorTable {\n    constructor(options) {\n        this.used = 0;\n        this.size = options.size;\n        this.fds = Array(options.size);\n        this.stdio = [options.in, options.out, options.err];\n        this.print = options.print;\n        this.printErr = options.printErr;\n        this.insertStdio(options.in, 0, '<stdin>');\n        this.insertStdio(options.out, 1, '<stdout>');\n        this.insertStdio(options.err, 2, '<stderr>');\n    }\n    insertStdio(fd, expected, name) {\n        const type = 2 /* WasiFileType.CHARACTER_DEVICE */;\n        const { base, inheriting } = getRights(this.stdio, fd, 2 /* FileControlFlag.O_RDWR */, type);\n        const wrap = this.insert(fd, name, name, type, base, inheriting, 0);\n        if (wrap.id !== expected) {\n            throw new WasiError(`id: ${wrap.id} !== expected: ${expected}`, 8 /* WasiErrno.EBADF */);\n        }\n        return wrap;\n    }\n    insert(fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen) {\n        var _a, _b;\n        let index = -1;\n        if (this.used >= this.size) {\n            const newSize = this.size * 2;\n            this.fds.length = newSize;\n            index = this.size;\n            this.size = newSize;\n        }\n        else {\n            for (let i = 0; i < this.size; ++i) {\n                if (this.fds[i] == null) {\n                    index = i;\n                    break;\n                }\n            }\n        }\n        let entry;\n        if (mappedPath === '<stdout>') {\n            entry = new StandardOutput((_a = this.print) !== null && _a !== void 0 ? _a : console.log, index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen);\n        }\n        else if (mappedPath === '<stderr>') {\n            entry = new StandardOutput((_b = this.printErr) !== null && _b !== void 0 ? _b : console.error, index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen);\n        }\n        else {\n            entry = new FileDescriptor(index, fd, mappedPath, realPath, type, rightsBase, rightsInheriting, preopen);\n        }\n        this.fds[index] = entry;\n        this.used++;\n        return entry;\n    }\n    get(id, base, inheriting) {\n        if (id >= this.size) {\n            throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */);\n        }\n        const entry = this.fds[id];\n        if (!entry || entry.id !== id) {\n            throw new WasiError('Bad file descriptor', 8 /* WasiErrno.EBADF */);\n        }\n        /* Validate that the fd has the necessary rights. */\n        if ((~entry.rightsBase & base) !== BigInt(0) || (~entry.rightsInheriting & inheriting) !== BigInt(0)) {\n            throw new WasiError('Capabilities insufficient', 76 /* WasiErrno.ENOTCAPABLE */);\n        }\n        return entry;\n    }\n    remove(id) {\n        if (id >= this.size) {\n            throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */);\n        }\n        const entry = this.fds[id];\n        if (!entry || entry.id !== id) {\n            throw new WasiError('Bad file descriptor', 8 /* WasiErrno.EBADF */);\n        }\n        this.fds[id] = undefined;\n        this.used--;\n    }\n}\nclass SyncTable extends FileDescriptorTable {\n    constructor(options) {\n        super(options);\n        this.fs = options.fs;\n    }\n    getFileTypeByFd(fd) {\n        const stats = this.fs.fstatSync(fd, { bigint: true });\n        return toFileType(stats);\n    }\n    insertPreopen(fd, mappedPath, realPath) {\n        const type = this.getFileTypeByFd(fd);\n        if (type !== 3 /* WasiFileType.DIRECTORY */) {\n            throw new WasiError(`Preopen not dir: [\"${mappedPath}\", \"${realPath}\"]`, 54 /* WasiErrno.ENOTDIR */);\n        }\n        const result = getRights(this.stdio, fd, 0, type);\n        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);\n    }\n    renumber(dst, src) {\n        if (dst === src)\n            return;\n        if (dst >= this.size || src >= this.size) {\n            throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */);\n        }\n        const dstEntry = this.fds[dst];\n        const srcEntry = this.fds[src];\n        if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) {\n            throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */);\n        }\n        this.fs.closeSync(dstEntry.fd);\n        this.fds[dst] = this.fds[src];\n        this.fds[dst].id = dst;\n        this.fds[src] = undefined;\n        this.used--;\n    }\n}\nclass AsyncTable extends FileDescriptorTable {\n    // eslint-disable-next-line @typescript-eslint/no-useless-constructor\n    constructor(options) {\n        super(options);\n    }\n    async getFileTypeByFd(fd) {\n        const stats = await fd.stat({ bigint: true });\n        return toFileType(stats);\n    }\n    async insertPreopen(fd, mappedPath, realPath) {\n        const type = await this.getFileTypeByFd(fd);\n        if (type !== 3 /* WasiFileType.DIRECTORY */) {\n            throw new WasiError(`Preopen not dir: [\"${mappedPath}\", \"${realPath}\"]`, 54 /* WasiErrno.ENOTDIR */);\n        }\n        const result = getRights(this.stdio, fd.fd, 0, type);\n        return this.insert(fd, mappedPath, realPath, type, result.base, result.inheriting, 1);\n    }\n    async renumber(dst, src) {\n        if (dst === src)\n            return;\n        if (dst >= this.size || src >= this.size) {\n            throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */);\n        }\n        const dstEntry = this.fds[dst];\n        const srcEntry = this.fds[src];\n        if (!dstEntry || !srcEntry || dstEntry.id !== dst || srcEntry.id !== src) {\n            throw new WasiError('Invalid fd', 8 /* WasiErrno.EBADF */);\n        }\n        await dstEntry.fd.close();\n        this.fds[dst] = this.fds[src];\n        this.fds[dst].id = dst;\n        this.fds[src] = undefined;\n        this.used--;\n    }\n}\n\n/** @public */\nconst WebAssemblyMemory = /*#__PURE__*/ (function () { return _WebAssembly.Memory; })();\n/** @public */\nclass Memory extends WebAssemblyMemory {\n    // eslint-disable-next-line @typescript-eslint/no-useless-constructor\n    constructor(descriptor) {\n        super(descriptor);\n    }\n    get HEAP8() { return new Int8Array(super.buffer); }\n    get HEAPU8() { return new Uint8Array(super.buffer); }\n    get HEAP16() { return new Int16Array(super.buffer); }\n    get HEAPU16() { return new Uint16Array(super.buffer); }\n    get HEAP32() { return new Int32Array(super.buffer); }\n    get HEAPU32() { return new Uint32Array(super.buffer); }\n    get HEAP64() { return new BigInt64Array(super.buffer); }\n    get HEAPU64() { return new BigUint64Array(super.buffer); }\n    get HEAPF32() { return new Float32Array(super.buffer); }\n    get HEAPF64() { return new Float64Array(super.buffer); }\n    get view() { return new DataView(super.buffer); }\n}\n/** @public */\nfunction extendMemory(memory) {\n    if (Object.getPrototypeOf(memory) === _WebAssembly.Memory.prototype) {\n        Object.setPrototypeOf(memory, Memory.prototype);\n    }\n    return memory;\n}\n\nfunction checkWebAssemblyFunction() {\n    const WebAssemblyFunction = _WebAssembly.Function;\n    if (typeof WebAssemblyFunction !== 'function') {\n        throw new Error('WebAssembly.Function is not supported in this environment.' +\n            ' If you are using V8 based browser like Chrome, try to specify' +\n            ' --js-flags=\"--wasm-staging --experimental-wasm-stack-switching\"');\n    }\n    return WebAssemblyFunction;\n}\n/** @public */\nfunction wrapAsyncImport(f, parameterType, returnType) {\n    const WebAssemblyFunction = checkWebAssemblyFunction();\n    if (typeof f !== 'function') {\n        throw new TypeError('Function required');\n    }\n    const parameters = parameterType.slice(0);\n    parameters.unshift('externref');\n    return new WebAssemblyFunction({ parameters, results: returnType }, f, { suspending: 'first' });\n}\n/** @public */\nfunction wrapAsyncExport(f) {\n    const WebAssemblyFunction = checkWebAssemblyFunction();\n    if (typeof f !== 'function') {\n        throw new TypeError('Function required');\n    }\n    return new WebAssemblyFunction({ parameters: [...WebAssemblyFunction.type(f).parameters.slice(1)], results: ['externref'] }, f, { promising: 'first' });\n}\n/** @public */\nfunction wrapExports(exports, needWrap) {\n    return wrapInstanceExports(exports, (exportValue, name) => {\n        let ignore = typeof exportValue !== 'function';\n        if (Array.isArray(needWrap)) {\n            ignore = ignore || (needWrap.indexOf(name) === -1);\n        }\n        return ignore ? exportValue : wrapAsyncExport(exportValue);\n    });\n}\n\nfunction copyMemory(targets, src) {\n    if (targets.length === 0 || src.length === 0)\n        return 0;\n    let copied = 0;\n    let left = src.length - copied;\n    for (let i = 0; i < targets.length; ++i) {\n        const target = targets[i];\n        if (left < target.length) {\n            target.set(src.subarray(copied, copied + left), 0);\n            copied += left;\n            left = 0;\n            return copied;\n        }\n        target.set(src.subarray(copied, copied + target.length), 0);\n        copied += target.length;\n        left -= target.length;\n    }\n    return copied;\n}\nconst _memory = new WeakMap();\nconst _wasi = new WeakMap();\nconst _fs = new WeakMap();\nfunction getMemory(wasi) {\n    return _memory.get(wasi);\n}\nfunction getFs(wasi) {\n    const fs = _fs.get(wasi);\n    if (!fs)\n        throw new Error('filesystem is unavailable');\n    return fs;\n}\nfunction handleError(err) {\n    if (err instanceof WasiError) {\n        if (((process.env.NODE_ENV)) !== 'production') {\n            console.warn(err);\n        }\n        return err.errno;\n    }\n    switch (err.code) {\n        case 'ENOENT': return 44 /* WasiErrno.ENOENT */;\n        case 'EBADF': return 8 /* WasiErrno.EBADF */;\n        case 'EINVAL': return 28 /* WasiErrno.EINVAL */;\n        case 'EPERM': return 63 /* WasiErrno.EPERM */;\n        case 'EPROTO': return 65 /* WasiErrno.EPROTO */;\n        case 'EEXIST': return 20 /* WasiErrno.EEXIST */;\n        case 'ENOTDIR': return 54 /* WasiErrno.ENOTDIR */;\n        case 'EMFILE': return 33 /* WasiErrno.EMFILE */;\n        case 'EACCES': return 2 /* WasiErrno.EACCES */;\n        case 'EISDIR': return 31 /* WasiErrno.EISDIR */;\n        case 'ENOTEMPTY': return 55 /* WasiErrno.ENOTEMPTY */;\n        case 'ENOSYS': return 52 /* WasiErrno.ENOSYS */;\n    }\n    throw err;\n}\nfunction defineName(name, f) {\n    Object.defineProperty(f, 'name', { value: name });\n    return f;\n}\nfunction syscallWrap(self, name, f) {\n    return defineName(name, function () {\n        if (process.env.NODE_DEBUG_NATIVE === 'wasi') {\n            const args = Array.prototype.slice.call(arguments);\n            let debugArgs = [`${name}(${Array.from({ length: arguments.length }).map(() => '%d').join(', ')})`];\n            debugArgs = debugArgs.concat(args);\n            console.debug.apply(console, debugArgs);\n        }\n        let r;\n        try {\n            r = f.apply(self, arguments);\n        }\n        catch (err) {\n            return handleError(err);\n        }\n        if (isPromiseLike(r)) {\n            return r.then(_ => _, handleError);\n        }\n        return r;\n    });\n}\nfunction resolvePathSync(fs, fileDescriptor, path, flags) {\n    let resolvedPath = resolve(fileDescriptor.realPath, path);\n    if ((flags & 1) === 1) {\n        try {\n            resolvedPath = fs.readlinkSync(resolvedPath);\n        }\n        catch (err) {\n            if (err.code !== 'EINVAL' && err.code !== 'ENOENT') {\n                throw err;\n            }\n        }\n    }\n    return resolvedPath;\n}\nasync function resolvePathAsync(fs, fileDescriptor, path, flags) {\n    let resolvedPath = resolve(fileDescriptor.realPath, path);\n    if ((flags & 1) === 1) {\n        try {\n            resolvedPath = await fs.promises.readlink(resolvedPath);\n        }\n        catch (err) {\n            if (err.code !== 'EINVAL' && err.code !== 'ENOENT') {\n                throw err;\n            }\n        }\n    }\n    return resolvedPath;\n}\n// eslint-disable-next-line spaced-comment\nconst encoder = /*#__PURE__*/ new TextEncoder();\n// eslint-disable-next-line spaced-comment\nconst decoder = /*#__PURE__*/ new TextDecoder();\nconst INT64_MAX = (BigInt(1) << BigInt(63)) - BigInt(1);\nfunction readStdin() {\n    const value = window.prompt();\n    if (value === null)\n        return new Uint8Array();\n    const buffer = new TextEncoder().encode(value + '\\n');\n    return buffer;\n}\nfunction validateFstFlagsOrReturn(flags) {\n    return (Boolean((flags) & ~(1 /* WasiFstFlag.SET_ATIM */ | 2 /* WasiFstFlag.SET_ATIM_NOW */ |\n        4 /* WasiFstFlag.SET_MTIM */ | 8 /* WasiFstFlag.SET_MTIM_NOW */)) ||\n        ((flags) & (1 /* WasiFstFlag.SET_ATIM */ | 2 /* WasiFstFlag.SET_ATIM_NOW */)) ===\n            (1 /* WasiFstFlag.SET_ATIM */ | 2 /* WasiFstFlag.SET_ATIM_NOW */) ||\n        ((flags) & (4 /* WasiFstFlag.SET_MTIM */ | 8 /* WasiFstFlag.SET_MTIM_NOW */)) ===\n            (4 /* WasiFstFlag.SET_MTIM */ | 8 /* WasiFstFlag.SET_MTIM_NOW */));\n}\nclass WASI$1 {\n    constructor(args, env, fds, asyncFs, fs, asyncify) {\n        this.args_get = syscallWrap(this, 'args_get', function (argv, argv_buf) {\n            argv = Number(argv);\n            argv_buf = Number(argv_buf);\n            if (argv === 0 || argv_buf === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const args = wasi.args;\n            for (let i = 0; i < args.length; ++i) {\n                const arg = args[i];\n                view.setInt32(argv, argv_buf, true);\n                argv += 4;\n                const data = encoder.encode(arg + '\\0');\n                HEAPU8.set(data, argv_buf);\n                argv_buf += data.length;\n            }\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.args_sizes_get = syscallWrap(this, 'args_sizes_get', function (argc, argv_buf_size) {\n            argc = Number(argc);\n            argv_buf_size = Number(argv_buf_size);\n            if (argc === 0 || argv_buf_size === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const args = wasi.args;\n            view.setUint32(argc, args.length, true);\n            view.setUint32(argv_buf_size, encoder.encode(args.join('\\0') + '\\0').length, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.environ_get = syscallWrap(this, 'environ_get', function (environ, environ_buf) {\n            environ = Number(environ);\n            environ_buf = Number(environ_buf);\n            if (environ === 0 || environ_buf === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const env = wasi.env;\n            for (let i = 0; i < env.length; ++i) {\n                const pair = env[i];\n                view.setInt32(environ, environ_buf, true);\n                environ += 4;\n                const data = encoder.encode(pair + '\\0');\n                HEAPU8.set(data, environ_buf);\n                environ_buf += data.length;\n            }\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.environ_sizes_get = syscallWrap(this, 'environ_sizes_get', function (len, buflen) {\n            len = Number(len);\n            buflen = Number(buflen);\n            if (len === 0 || buflen === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            view.setUint32(len, wasi.env.length, true);\n            view.setUint32(buflen, encoder.encode(wasi.env.join('\\0') + '\\0').length, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.clock_res_get = syscallWrap(this, 'clock_res_get', function (id, resolution) {\n            resolution = Number(resolution);\n            if (resolution === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { view } = getMemory(this);\n            switch (id) {\n                case 0 /* WasiClockid.REALTIME */:\n                    view.setBigUint64(resolution, BigInt(1000000), true);\n                    return 0 /* WasiErrno.ESUCCESS */;\n                case 1 /* WasiClockid.MONOTONIC */:\n                case 2 /* WasiClockid.PROCESS_CPUTIME_ID */:\n                case 3 /* WasiClockid.THREAD_CPUTIME_ID */:\n                    view.setBigUint64(resolution, BigInt(1000), true);\n                    return 0 /* WasiErrno.ESUCCESS */;\n                default: return 28 /* WasiErrno.EINVAL */;\n            }\n        });\n        this.clock_time_get = syscallWrap(this, 'clock_time_get', function (id, _percision, time) {\n            time = Number(time);\n            if (time === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { view } = getMemory(this);\n            switch (id) {\n                case 0 /* WasiClockid.REALTIME */:\n                    view.setBigUint64(time, BigInt(Date.now()) * BigInt(1000000), true);\n                    return 0 /* WasiErrno.ESUCCESS */;\n                case 1 /* WasiClockid.MONOTONIC */:\n                case 2 /* WasiClockid.PROCESS_CPUTIME_ID */:\n                case 3 /* WasiClockid.THREAD_CPUTIME_ID */: {\n                    const t = performance.now();\n                    const s = Math.trunc(t);\n                    const ms = Math.floor((t - s) * 1000);\n                    const result = BigInt(s) * BigInt(1000000000) + BigInt(ms) * BigInt(1000000);\n                    view.setBigUint64(time, result, true);\n                    return 0 /* WasiErrno.ESUCCESS */;\n                }\n                default: return 28 /* WasiErrno.EINVAL */;\n            }\n        });\n        this.fd_advise = syscallWrap(this, 'fd_advise', function (_fd, _offset, _len, _advice) {\n            return 52 /* WasiErrno.ENOSYS */;\n        });\n        this.fd_fdstat_get = syscallWrap(this, 'fd_fdstat_get', function (fd, fdstat) {\n            fdstat = Number(fdstat);\n            if (fdstat === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));\n            const { view } = getMemory(this);\n            view.setUint16(fdstat, fileDescriptor.type, true);\n            view.setUint16(fdstat + 2, 0, true);\n            view.setBigUint64(fdstat + 8, fileDescriptor.rightsBase, true);\n            view.setBigUint64(fdstat + 16, fileDescriptor.rightsInheriting, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.fd_fdstat_set_flags = syscallWrap(this, 'fd_fdstat_set_flags', function (_fd, _flags) {\n            return 52 /* WasiErrno.ENOSYS */;\n        });\n        this.fd_fdstat_set_rights = syscallWrap(this, 'fd_fdstat_set_rights', function (fd, rightsBase, rightsInheriting) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));\n            if ((rightsBase | fileDescriptor.rightsBase) > fileDescriptor.rightsBase) {\n                return 76 /* WasiErrno.ENOTCAPABLE */;\n            }\n            if ((rightsInheriting | fileDescriptor.rightsInheriting) >\n                fileDescriptor.rightsInheriting) {\n                return 76 /* WasiErrno.ENOTCAPABLE */;\n            }\n            fileDescriptor.rightsBase = rightsBase;\n            fileDescriptor.rightsInheriting = rightsInheriting;\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.fd_prestat_get = syscallWrap(this, 'fd_prestat_get', function (fd, prestat) {\n            prestat = Number(prestat);\n            if (prestat === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const wasi = _wasi.get(this);\n            let fileDescriptor;\n            try {\n                fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));\n            }\n            catch (err) {\n                if (err instanceof WasiError)\n                    return err.errno;\n                throw err;\n            }\n            if (fileDescriptor.preopen !== 1)\n                return 28 /* WasiErrno.EINVAL */;\n            const { view } = getMemory(this);\n            // preopen type is dir(0)\n            view.setUint32(prestat, 0, true);\n            view.setUint32(prestat + 4, encoder.encode(fileDescriptor.path).length, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.fd_prestat_dir_name = syscallWrap(this, 'fd_prestat_dir_name', function (fd, path, path_len) {\n            path = Number(path);\n            path_len = Number(path_len);\n            if (path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));\n            if (fileDescriptor.preopen !== 1)\n                return 8 /* WasiErrno.EBADF */;\n            const buffer = encoder.encode(fileDescriptor.path);\n            const size = buffer.length;\n            if (size > path_len)\n                return 42 /* WasiErrno.ENOBUFS */;\n            const { HEAPU8 } = getMemory(this);\n            HEAPU8.set(buffer, path);\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.fd_seek = syscallWrap(this, 'fd_seek', function (fd, offset, whence, newOffset) {\n            newOffset = Number(newOffset);\n            if (newOffset === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            if (fd === 0 || fd === 1 || fd === 2)\n                return 0 /* WasiErrno.ESUCCESS */;\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_SEEK, BigInt(0));\n            const r = fileDescriptor.seek(offset, whence);\n            const { view } = getMemory(this);\n            view.setBigUint64(newOffset, r, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.fd_tell = syscallWrap(this, 'fd_tell', function (fd, offset) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_TELL, BigInt(0));\n            const pos = BigInt(fileDescriptor.pos);\n            const { view } = getMemory(this);\n            view.setBigUint64(Number(offset), pos, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.poll_oneoff = syscallWrap(this, 'poll_oneoff', function (in_ptr, out_ptr, nsubscriptions, nevents) {\n            in_ptr = Number(in_ptr);\n            out_ptr = Number(out_ptr);\n            nevents = Number(nevents);\n            nsubscriptions = Number(nsubscriptions);\n            nsubscriptions = nsubscriptions >>> 0;\n            if (in_ptr === 0 || out_ptr === 0 || nsubscriptions === 0 || nevents === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { view } = getMemory(this);\n            view.setUint32(nevents, 0, true);\n            let i = 0;\n            let timer_userdata = BigInt(0);\n            let cur_timeout = BigInt(0);\n            let has_timeout = 0;\n            let min_timeout = BigInt(0);\n            let sub;\n            const subscriptions = Array(nsubscriptions);\n            for (i = 0; i < nsubscriptions; i++) {\n                sub = in_ptr + i * 48;\n                const userdata = view.getBigUint64(sub, true);\n                const type = view.getUint8(sub + 8);\n                const clockIdOrFd = view.getUint32(sub + 16, true);\n                const timeout = view.getBigUint64(sub + 24, true);\n                const precision = view.getBigUint64(sub + 32, true);\n                const flags = view.getUint16(sub + 40, true);\n                subscriptions[i] = {\n                    userdata,\n                    type,\n                    u: {\n                        clock: {\n                            clock_id: clockIdOrFd,\n                            timeout,\n                            precision,\n                            flags\n                        },\n                        fd_readwrite: {\n                            fd: clockIdOrFd\n                        }\n                    }\n                };\n            }\n            const fdevents = [];\n            for (i = 0; i < nsubscriptions; i++) {\n                sub = subscriptions[i];\n                switch (sub.type) {\n                    case 0 /* WasiEventType.CLOCK */: {\n                        if (sub.u.clock.flags === 1 /* WasiSubclockflags.ABSTIME */) {\n                            /* Convert absolute time to relative delay. */\n                            const now = BigInt(Date.now()) * BigInt(1000000);\n                            cur_timeout = sub.u.clock.timeout - now;\n                        }\n                        else {\n                            cur_timeout = sub.u.clock.timeout;\n                        }\n                        if (has_timeout === 0 || cur_timeout < min_timeout) {\n                            min_timeout = cur_timeout;\n                            timer_userdata = sub.userdata;\n                            has_timeout = 1;\n                        }\n                        break;\n                    }\n                    case 1 /* WasiEventType.FD_READ */:\n                    case 2 /* WasiEventType.FD_WRITE */:\n                        fdevents.push(sub);\n                        break;\n                    default: return 28 /* WasiErrno.EINVAL */;\n                }\n            }\n            if (fdevents.length > 0) {\n                for (i = 0; i < fdevents.length; i++) {\n                    const fdevent = fdevents[i];\n                    const event = out_ptr + 32 * i;\n                    view.setBigUint64(event, fdevent.userdata, true);\n                    view.setUint32(event + 8, 52 /* WasiErrno.ENOSYS */, true);\n                    view.setUint32(event + 12, fdevent.type, true);\n                    view.setBigUint64(event + 16, BigInt(0), true);\n                    view.setUint16(event + 24, 0, true);\n                    view.setUint32(nevents, 1, true);\n                }\n                view.setUint32(nevents, fdevents.length, true);\n                return 0 /* WasiErrno.ESUCCESS */;\n            }\n            if (has_timeout) {\n                const delay = Number(min_timeout / BigInt(1000000));\n                // if (isMainThread || typeof SharedArrayBuffer !== 'function') {\n                sleepBreakIf(delay, () => false);\n                // } else {\n                //   const buf = new SharedArrayBuffer(4)\n                //   const arr = new Int32Array(buf)\n                //   postMsg({\n                //     __tybys_wasm_util_wasi__: {\n                //       type: 'set-timeout',\n                //       payload: {\n                //         buffer: buf,\n                //         delay\n                //       }\n                //     }\n                //   })\n                //   Atomics.wait(arr, 0, 0)\n                // }\n                const event = out_ptr;\n                view.setBigUint64(event, timer_userdata, true);\n                view.setUint32(event + 8, 0 /* WasiErrno.ESUCCESS */, true);\n                view.setUint32(event + 12, 0 /* WasiEventType.CLOCK */, true);\n                view.setUint32(nevents, 1, true);\n            }\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.proc_exit = syscallWrap(this, 'proc_exit', function (rval) {\n            if ((typeof process === 'object') && (process !== null) && (typeof process.exit === 'function')) {\n                process.exit(rval);\n            }\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.proc_raise = syscallWrap(this, 'proc_raise', function (_sig) {\n            return 52 /* WasiErrno.ENOSYS */;\n        });\n        this.sched_yield = syscallWrap(this, 'sched_yield', function () {\n            return 0 /* WasiErrno.ESUCCESS */;\n        });\n        this.random_get = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function'\n            ? syscallWrap(this, 'random_get', function (buf, buf_len) {\n                buf = Number(buf);\n                if (buf === 0) {\n                    return 28 /* WasiErrno.EINVAL */;\n                }\n                buf_len = Number(buf_len);\n                const { HEAPU8, view } = getMemory(this);\n                if ((typeof SharedArrayBuffer === 'function' && HEAPU8.buffer instanceof SharedArrayBuffer) ||\n                    (Object.prototype.toString.call(HEAPU8.buffer) === '[object SharedArrayBuffer]')) {\n                    for (let i = buf; i < buf + buf_len; ++i) {\n                        view.setUint8(i, Math.floor(Math.random() * 256));\n                    }\n                    return 0 /* WasiErrno.ESUCCESS */;\n                }\n                let pos;\n                const stride = 65536;\n                for (pos = 0; pos + stride < buf_len; pos += stride) {\n                    crypto.getRandomValues(HEAPU8.subarray(buf + pos, buf + pos + stride));\n                }\n                crypto.getRandomValues(HEAPU8.subarray(buf + pos, buf + buf_len));\n                return 0 /* WasiErrno.ESUCCESS */;\n            })\n            : syscallWrap(this, 'random_get', function (buf, buf_len) {\n                buf = Number(buf);\n                if (buf === 0) {\n                    return 28 /* WasiErrno.EINVAL */;\n                }\n                buf_len = Number(buf_len);\n                const { view } = getMemory(this);\n                for (let i = buf; i < buf + buf_len; ++i) {\n                    view.setUint8(i, Math.floor(Math.random() * 256));\n                }\n                return 0 /* WasiErrno.ESUCCESS */;\n            });\n        this.sock_recv = syscallWrap(this, 'sock_recv', function () {\n            return 58 /* WasiErrno.ENOTSUP */;\n        });\n        this.sock_send = syscallWrap(this, 'sock_send', function () {\n            return 58 /* WasiErrno.ENOTSUP */;\n        });\n        this.sock_shutdown = syscallWrap(this, 'sock_shutdown', function () {\n            return 58 /* WasiErrno.ENOTSUP */;\n        });\n        this.sock_accept = syscallWrap(this, 'sock_accept', function () {\n            return 58 /* WasiErrno.ENOTSUP */;\n        });\n        _wasi.set(this, {\n            fds,\n            args,\n            env\n        });\n        if (fs)\n            _fs.set(this, fs);\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        const _this = this;\n        function defineImport(name, syncVersion, asyncVersion, parameterType, returnType) {\n            if (asyncFs) {\n                if (asyncify) {\n                    _this[name] = asyncify.wrapImportFunction(syscallWrap(_this, name, asyncVersion));\n                }\n                else {\n                    _this[name] = wrapAsyncImport(syscallWrap(_this, name, asyncVersion), parameterType, returnType);\n                }\n            }\n            else {\n                _this[name] = syscallWrap(_this, name, syncVersion);\n            }\n        }\n        defineImport('fd_allocate', function fd_allocate(fd, offset, len) {\n            const wasi = _wasi.get(this);\n            const fs = getFs(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_ALLOCATE, BigInt(0));\n            const stat = fs.fstatSync(fileDescriptor.fd, { bigint: true });\n            if (stat.size < offset + len) {\n                fs.ftruncateSync(fileDescriptor.fd, Number(offset + len));\n            }\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_allocate(fd, offset, len) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_ALLOCATE, BigInt(0));\n            const h = fileDescriptor.fd;\n            const stat = await h.stat({ bigint: true });\n            if (stat.size < offset + len) {\n                await h.truncate(Number(offset + len));\n            }\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i64', 'f64'], ['i32']);\n        defineImport('fd_close', function fd_close(fd) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));\n            const fs = getFs(this);\n            fs.closeSync(fileDescriptor.fd);\n            wasi.fds.remove(fd);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_close(fd) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, BigInt(0), BigInt(0));\n            await fileDescriptor.fd.close();\n            wasi.fds.remove(fd);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32'], ['i32']);\n        defineImport('fd_datasync', function fd_datasync(fd) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_DATASYNC, BigInt(0));\n            const fs = getFs(this);\n            fs.fdatasyncSync(fileDescriptor.fd);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_datasync(fd) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_DATASYNC, BigInt(0));\n            await fileDescriptor.fd.datasync();\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32'], ['i32']);\n        defineImport('fd_filestat_get', function fd_filestat_get(fd, buf) {\n            buf = Number(buf);\n            if (buf === 0)\n                return 28 /* WasiErrno.EINVAL */;\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_GET, BigInt(0));\n            const fs = getFs(this);\n            const stat = fs.fstatSync(fileDescriptor.fd, { bigint: true });\n            const { view } = getMemory(this);\n            toFileStat(view, buf, stat);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_filestat_get(fd, buf) {\n            buf = Number(buf);\n            if (buf === 0)\n                return 28 /* WasiErrno.EINVAL */;\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_GET, BigInt(0));\n            const h = fileDescriptor.fd;\n            const stat = await h.stat({ bigint: true });\n            const { view } = getMemory(this);\n            toFileStat(view, buf, stat);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32'], ['i32']);\n        defineImport('fd_filestat_set_size', function fd_filestat_set_size(fd, size) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_SIZE, BigInt(0));\n            const fs = getFs(this);\n            fs.ftruncateSync(fileDescriptor.fd, Number(size));\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_filestat_set_size(fd, size) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_SIZE, BigInt(0));\n            const h = fileDescriptor.fd;\n            await h.truncate(Number(size));\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i64'], ['i32']);\n        function fdFilestatGetTimes(fd, atim, mtim, flags) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_FILESTAT_SET_TIMES, BigInt(0));\n            if ((flags & 2 /* WasiFstFlag.SET_ATIM_NOW */) === 2 /* WasiFstFlag.SET_ATIM_NOW */) {\n                atim = BigInt(Date.now() * 1000000);\n            }\n            if ((flags & 8 /* WasiFstFlag.SET_MTIM_NOW */) === 8 /* WasiFstFlag.SET_MTIM_NOW */) {\n                mtim = BigInt(Date.now() * 1000000);\n            }\n            return { fileDescriptor, atim, mtim };\n        }\n        defineImport('fd_filestat_set_times', function fd_filestat_set_times(fd, atim, mtim, flags) {\n            if (validateFstFlagsOrReturn(flags)) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { fileDescriptor, atim: atimRes, mtim: mtimRes } = fdFilestatGetTimes.call(this, fd, atim, mtim, flags);\n            const fs = getFs(this);\n            fs.futimesSync(fileDescriptor.fd, Number(atimRes), Number(mtimRes));\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_filestat_set_times(fd, atim, mtim, flags) {\n            if (validateFstFlagsOrReturn(flags)) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { fileDescriptor, atim: atimRes, mtim: mtimRes } = fdFilestatGetTimes.call(this, fd, atim, mtim, flags);\n            const h = fileDescriptor.fd;\n            await h.utimes(Number(atimRes), Number(mtimRes));\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i64', 'i64', 'i32'], ['i32']);\n        defineImport('fd_pread', function fd_pread(fd, iovs, iovslen, offset, size) {\n            iovs = Number(iovs);\n            size = Number(size);\n            if ((iovs === 0 && iovslen) || size === 0 || offset > INT64_MAX) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ | WasiRights.FD_SEEK, BigInt(0));\n            if (!iovslen) {\n                view.setUint32(size, 0, true);\n                return 0 /* WasiErrno.ESUCCESS */;\n            }\n            let totalSize = 0;\n            const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {\n                const offset = iovs + (i * 8);\n                const buf = view.getInt32(offset, true);\n                const bufLen = view.getUint32(offset + 4, true);\n                totalSize += bufLen;\n                return HEAPU8.subarray(buf, buf + bufLen);\n            });\n            let nread = 0;\n            const buffer = (() => {\n                try {\n                    return new Uint8Array(new SharedArrayBuffer(totalSize));\n                }\n                catch (_) {\n                    return new Uint8Array(totalSize);\n                }\n            })();\n            buffer._isBuffer = true;\n            const fs = getFs(this);\n            const bytesRead = fs.readSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(offset));\n            nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;\n            view.setUint32(size, nread, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function (fd, iovs, iovslen, offset, size) {\n            iovs = Number(iovs);\n            size = Number(size);\n            if ((iovs === 0 && iovslen) || size === 0 || offset > INT64_MAX) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ | WasiRights.FD_SEEK, BigInt(0));\n            if (!iovslen) {\n                view.setUint32(size, 0, true);\n                return 0 /* WasiErrno.ESUCCESS */;\n            }\n            let totalSize = 0;\n            const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {\n                const offset = iovs + (i * 8);\n                const buf = view.getInt32(offset, true);\n                const bufLen = view.getUint32(offset + 4, true);\n                totalSize += bufLen;\n                return HEAPU8.subarray(buf, buf + bufLen);\n            });\n            let nread = 0;\n            const buffer = new Uint8Array(totalSize);\n            buffer._isBuffer = true;\n            const { bytesRead } = await fileDescriptor.fd.read(buffer, 0, buffer.length, Number(offset));\n            nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;\n            view.setUint32(size, nread, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i64', 'i32'], ['i32']);\n        defineImport('fd_pwrite', function fd_pwrite(fd, iovs, iovslen, offset, size) {\n            iovs = Number(iovs);\n            size = Number(size);\n            if ((iovs === 0 && iovslen) || size === 0 || offset > INT64_MAX) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE | WasiRights.FD_SEEK, BigInt(0));\n            if (!iovslen) {\n                view.setUint32(size, 0, true);\n                return 0 /* WasiErrno.ESUCCESS */;\n            }\n            const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {\n                const offset = iovs + (i * 8);\n                const buf = view.getInt32(offset, true);\n                const bufLen = view.getUint32(offset + 4, true);\n                return HEAPU8.subarray(buf, buf + bufLen);\n            }));\n            const fs = getFs(this);\n            const nwritten = fs.writeSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(offset));\n            view.setUint32(size, nwritten, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_pwrite(fd, iovs, iovslen, offset, size) {\n            iovs = Number(iovs);\n            size = Number(size);\n            if ((iovs === 0 && iovslen) || size === 0 || offset > INT64_MAX) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE | WasiRights.FD_SEEK, BigInt(0));\n            if (!iovslen) {\n                view.setUint32(size, 0, true);\n                return 0 /* WasiErrno.ESUCCESS */;\n            }\n            const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {\n                const offset = iovs + (i * 8);\n                const buf = view.getInt32(offset, true);\n                const bufLen = view.getUint32(offset + 4, true);\n                return HEAPU8.subarray(buf, buf + bufLen);\n            }));\n            const { bytesWritten } = await fileDescriptor.fd.write(buffer, 0, buffer.length, Number(offset));\n            view.setUint32(size, bytesWritten, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i64', 'i32'], ['i32']);\n        defineImport('fd_read', function fd_read(fd, iovs, iovslen, size) {\n            iovs = Number(iovs);\n            size = Number(size);\n            if ((iovs === 0 && iovslen) || size === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ, BigInt(0));\n            if (!iovslen) {\n                view.setUint32(size, 0, true);\n                return 0 /* WasiErrno.ESUCCESS */;\n            }\n            let totalSize = 0;\n            const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {\n                const offset = iovs + (i * 8);\n                const buf = view.getInt32(offset, true);\n                const bufLen = view.getUint32(offset + 4, true);\n                totalSize += bufLen;\n                return HEAPU8.subarray(buf, buf + bufLen);\n            });\n            let buffer;\n            let nread = 0;\n            if (fd === 0) {\n                if (typeof window === 'undefined' || typeof window.prompt !== 'function') {\n                    return 58 /* WasiErrno.ENOTSUP */;\n                }\n                buffer = readStdin();\n                nread = buffer ? copyMemory(ioVecs, buffer) : 0;\n            }\n            else {\n                buffer = (() => {\n                    try {\n                        return new Uint8Array(new SharedArrayBuffer(totalSize));\n                    }\n                    catch (_) {\n                        return new Uint8Array(totalSize);\n                    }\n                })();\n                buffer._isBuffer = true;\n                const fs = getFs(this);\n                const bytesRead = fs.readSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(fileDescriptor.pos));\n                nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;\n                fileDescriptor.pos += BigInt(nread);\n            }\n            view.setUint32(size, nread, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_read(fd, iovs, iovslen, size) {\n            iovs = Number(iovs);\n            size = Number(size);\n            if ((iovs === 0 && iovslen) || size === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READ, BigInt(0));\n            if (!iovslen) {\n                view.setUint32(size, 0, true);\n                return 0 /* WasiErrno.ESUCCESS */;\n            }\n            let totalSize = 0;\n            const ioVecs = Array.from({ length: Number(iovslen) }, (_, i) => {\n                const offset = iovs + (i * 8);\n                const buf = view.getInt32(offset, true);\n                const bufLen = view.getUint32(offset + 4, true);\n                totalSize += bufLen;\n                return HEAPU8.subarray(buf, buf + bufLen);\n            });\n            let buffer;\n            let nread = 0;\n            if (fd === 0) {\n                if (typeof window === 'undefined' || typeof window.prompt !== 'function') {\n                    return 58 /* WasiErrno.ENOTSUP */;\n                }\n                buffer = readStdin();\n                nread = buffer ? copyMemory(ioVecs, buffer) : 0;\n            }\n            else {\n                buffer = new Uint8Array(totalSize);\n                buffer._isBuffer = true;\n                const { bytesRead } = await fileDescriptor.fd.read(buffer, 0, buffer.length, Number(fileDescriptor.pos));\n                nread = buffer ? copyMemory(ioVecs, buffer.subarray(0, bytesRead)) : 0;\n                fileDescriptor.pos += BigInt(nread);\n            }\n            view.setUint32(size, nread, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i32'], ['i32']);\n        defineImport('fd_readdir', function fd_readdir(fd, buf, buf_len, cookie, bufused) {\n            buf = Number(buf);\n            buf_len = Number(buf_len);\n            bufused = Number(bufused);\n            if (buf === 0 || bufused === 0)\n                return 0 /* WasiErrno.ESUCCESS */;\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READDIR, BigInt(0));\n            const fs = getFs(this);\n            const entries = fs.readdirSync(fileDescriptor.realPath, { withFileTypes: true });\n            const { HEAPU8, view } = getMemory(this);\n            let bufferUsed = 0;\n            for (let i = Number(cookie); i < entries.length; i++) {\n                const nameData = encoder.encode(entries[i].name);\n                const entryInfo = fs.statSync(resolve(fileDescriptor.realPath, entries[i].name), { bigint: true });\n                const entryData = new Uint8Array(24 + nameData.byteLength);\n                const entryView = new DataView(entryData.buffer);\n                entryView.setBigUint64(0, BigInt(i + 1), true);\n                entryView.setBigUint64(8, BigInt(entryInfo.ino ? entryInfo.ino : 0), true);\n                entryView.setUint32(16, nameData.byteLength, true);\n                let type;\n                if (entries[i].isFile()) {\n                    type = 4 /* WasiFileType.REGULAR_FILE */;\n                }\n                else if (entries[i].isDirectory()) {\n                    type = 3 /* WasiFileType.DIRECTORY */;\n                }\n                else if (entries[i].isSymbolicLink()) {\n                    type = 7 /* WasiFileType.SYMBOLIC_LINK */;\n                }\n                else if (entries[i].isCharacterDevice()) {\n                    type = 2 /* WasiFileType.CHARACTER_DEVICE */;\n                }\n                else if (entries[i].isBlockDevice()) {\n                    type = 1 /* WasiFileType.BLOCK_DEVICE */;\n                }\n                else if (entries[i].isSocket()) {\n                    type = 6 /* WasiFileType.SOCKET_STREAM */;\n                }\n                else {\n                    type = 0 /* WasiFileType.UNKNOWN */;\n                }\n                entryView.setUint8(20, type);\n                entryData.set(nameData, 24);\n                const data = entryData.slice(0, Math.min(entryData.length, buf_len - bufferUsed));\n                HEAPU8.set(data, buf + bufferUsed);\n                bufferUsed += data.byteLength;\n            }\n            view.setUint32(bufused, bufferUsed, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_readdir(fd, buf, buf_len, cookie, bufused) {\n            buf = Number(buf);\n            buf_len = Number(buf_len);\n            bufused = Number(bufused);\n            if (buf === 0 || bufused === 0)\n                return 0 /* WasiErrno.ESUCCESS */;\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_READDIR, BigInt(0));\n            const fs = getFs(this);\n            const entries = await fs.promises.readdir(fileDescriptor.realPath, { withFileTypes: true });\n            const { HEAPU8, view } = getMemory(this);\n            let bufferUsed = 0;\n            for (let i = Number(cookie); i < entries.length; i++) {\n                const nameData = encoder.encode(entries[i].name);\n                const entryInfo = await fs.promises.stat(resolve(fileDescriptor.realPath, entries[i].name), { bigint: true });\n                const entryData = new Uint8Array(24 + nameData.byteLength);\n                const entryView = new DataView(entryData.buffer);\n                entryView.setBigUint64(0, BigInt(i + 1), true);\n                entryView.setBigUint64(8, BigInt(entryInfo.ino ? entryInfo.ino : 0), true);\n                entryView.setUint32(16, nameData.byteLength, true);\n                let type;\n                if (entries[i].isFile()) {\n                    type = 4 /* WasiFileType.REGULAR_FILE */;\n                }\n                else if (entries[i].isDirectory()) {\n                    type = 3 /* WasiFileType.DIRECTORY */;\n                }\n                else if (entries[i].isSymbolicLink()) {\n                    type = 7 /* WasiFileType.SYMBOLIC_LINK */;\n                }\n                else if (entries[i].isCharacterDevice()) {\n                    type = 2 /* WasiFileType.CHARACTER_DEVICE */;\n                }\n                else if (entries[i].isBlockDevice()) {\n                    type = 1 /* WasiFileType.BLOCK_DEVICE */;\n                }\n                else if (entries[i].isSocket()) {\n                    type = 6 /* WasiFileType.SOCKET_STREAM */;\n                }\n                else {\n                    type = 0 /* WasiFileType.UNKNOWN */;\n                }\n                entryView.setUint8(20, type);\n                entryData.set(nameData, 24);\n                const data = entryData.slice(0, Math.min(entryData.length, buf_len - bufferUsed));\n                HEAPU8.set(data, buf + bufferUsed);\n                bufferUsed += data.byteLength;\n            }\n            view.setUint32(bufused, bufferUsed, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i64', 'i32'], ['i32']);\n        defineImport('fd_renumber', function fd_renumber(from, to) {\n            const wasi = _wasi.get(this);\n            wasi.fds.renumber(to, from);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_renumber(from, to) {\n            const wasi = _wasi.get(this);\n            await wasi.fds.renumber(to, from);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32'], ['i32']);\n        defineImport('fd_sync', function fd_sync(fd) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_SYNC, BigInt(0));\n            const fs = getFs(this);\n            fs.fsyncSync(fileDescriptor.fd);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_sync(fd) {\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_SYNC, BigInt(0));\n            await fileDescriptor.fd.sync();\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32'], ['i32']);\n        defineImport('fd_write', function fd_write(fd, iovs, iovslen, size) {\n            iovs = Number(iovs);\n            size = Number(size);\n            if ((iovs === 0 && iovslen) || size === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE, BigInt(0));\n            if (!iovslen) {\n                view.setUint32(size, 0, true);\n                return 0 /* WasiErrno.ESUCCESS */;\n            }\n            const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {\n                const offset = iovs + (i * 8);\n                const buf = view.getInt32(offset, true);\n                const bufLen = view.getUint32(offset + 4, true);\n                return HEAPU8.subarray(buf, buf + bufLen);\n            }));\n            let nwritten;\n            if (fd === 1 || fd === 2) {\n                nwritten = fileDescriptor.write(buffer);\n            }\n            else {\n                const fs = getFs(this);\n                nwritten = fs.writeSync(fileDescriptor.fd, buffer, 0, buffer.length, Number(fileDescriptor.pos));\n                fileDescriptor.pos += BigInt(nwritten);\n            }\n            view.setUint32(size, nwritten, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function fd_write(fd, iovs, iovslen, size) {\n            iovs = Number(iovs);\n            size = Number(size);\n            if ((iovs === 0 && iovslen) || size === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.FD_WRITE, BigInt(0));\n            if (!iovslen) {\n                view.setUint32(size, 0, true);\n                return 0 /* WasiErrno.ESUCCESS */;\n            }\n            const buffer = concatBuffer(Array.from({ length: Number(iovslen) }, (_, i) => {\n                const offset = iovs + (i * 8);\n                const buf = view.getInt32(offset, true);\n                const bufLen = view.getUint32(offset + 4, true);\n                return HEAPU8.subarray(buf, buf + bufLen);\n            }));\n            let nwritten;\n            if (fd === 1 || fd === 2) {\n                nwritten = fileDescriptor.write(buffer);\n            }\n            else {\n                nwritten = await (await (fileDescriptor.fd.write(buffer, 0, buffer.length, Number(fileDescriptor.pos)))).bytesWritten;\n                fileDescriptor.pos += BigInt(nwritten);\n            }\n            view.setUint32(size, nwritten, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i32'], ['i32']);\n        defineImport('path_create_directory', function path_create_directory(fd, path, path_len) {\n            path = Number(path);\n            path_len = Number(path_len);\n            if (path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8 } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_CREATE_DIRECTORY, BigInt(0));\n            let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            pathString = resolve(fileDescriptor.realPath, pathString);\n            const fs = getFs(this);\n            fs.mkdirSync(pathString);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function path_create_directory(fd, path, path_len) {\n            path = Number(path);\n            path_len = Number(path_len);\n            if (path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8 } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_CREATE_DIRECTORY, BigInt(0));\n            let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            pathString = resolve(fileDescriptor.realPath, pathString);\n            const fs = getFs(this);\n            await fs.promises.mkdir(pathString);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32'], ['i32']);\n        defineImport('path_filestat_get', function path_filestat_get(fd, flags, path, path_len, filestat) {\n            path = Number(path);\n            path_len = Number(path_len);\n            filestat = Number(filestat);\n            if (path === 0 || filestat === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_GET, BigInt(0));\n            let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            const fs = getFs(this);\n            pathString = resolve(fileDescriptor.realPath, pathString);\n            let stat;\n            if ((flags & 1) === 1) {\n                stat = fs.statSync(pathString, { bigint: true });\n            }\n            else {\n                stat = fs.lstatSync(pathString, { bigint: true });\n            }\n            toFileStat(view, filestat, stat);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function path_filestat_get(fd, flags, path, path_len, filestat) {\n            path = Number(path);\n            path_len = Number(path_len);\n            filestat = Number(filestat);\n            if (path === 0 || filestat === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_GET, BigInt(0));\n            let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            const fs = getFs(this);\n            pathString = resolve(fileDescriptor.realPath, pathString);\n            let stat;\n            if ((flags & 1) === 1) {\n                stat = await fs.promises.stat(pathString, { bigint: true });\n            }\n            else {\n                stat = await fs.promises.lstat(pathString, { bigint: true });\n            }\n            toFileStat(view, filestat, stat);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i32', 'i32'], ['i32']);\n        defineImport('path_filestat_set_times', function path_filestat_set_times(fd, flags, path, path_len, atim, mtim, fst_flags) {\n            path = Number(path);\n            path_len = Number(path_len);\n            if (path === 0)\n                return 28 /* WasiErrno.EINVAL */;\n            const { HEAPU8 } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_SET_TIMES, BigInt(0));\n            if (validateFstFlagsOrReturn(fst_flags)) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const fs = getFs(this);\n            const resolvedPath = resolvePathSync(fs, fileDescriptor, decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)), flags);\n            if ((fst_flags & 2 /* WasiFstFlag.SET_ATIM_NOW */) === 2 /* WasiFstFlag.SET_ATIM_NOW */) {\n                atim = BigInt(Date.now() * 1000000);\n            }\n            if ((fst_flags & 8 /* WasiFstFlag.SET_MTIM_NOW */) === 8 /* WasiFstFlag.SET_MTIM_NOW */) {\n                mtim = BigInt(Date.now() * 1000000);\n            }\n            fs.utimesSync(resolvedPath, Number(atim), Number(mtim));\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function path_filestat_set_times(fd, flags, path, path_len, atim, mtim, fst_flags) {\n            path = Number(path);\n            path_len = Number(path_len);\n            if (path === 0)\n                return 28 /* WasiErrno.EINVAL */;\n            const { HEAPU8 } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_FILESTAT_SET_TIMES, BigInt(0));\n            if (validateFstFlagsOrReturn(fst_flags)) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const fs = getFs(this);\n            const resolvedPath = await resolvePathAsync(fs, fileDescriptor, decoder.decode(unsharedSlice(HEAPU8, path, path + path_len)), flags);\n            if ((fst_flags & 2 /* WasiFstFlag.SET_ATIM_NOW */) === 2 /* WasiFstFlag.SET_ATIM_NOW */) {\n                atim = BigInt(Date.now() * 1000000);\n            }\n            if ((fst_flags & 8 /* WasiFstFlag.SET_MTIM_NOW */) === 8 /* WasiFstFlag.SET_MTIM_NOW */) {\n                mtim = BigInt(Date.now() * 1000000);\n            }\n            await fs.promises.utimes(resolvedPath, Number(atim), Number(mtim));\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i32', 'i64', 'i64', 'i32'], ['i32']);\n        defineImport('path_link', function path_link(old_fd, old_flags, old_path, old_path_len, new_fd, new_path, new_path_len) {\n            old_path = Number(old_path);\n            old_path_len = Number(old_path_len);\n            new_path = Number(new_path);\n            new_path_len = Number(new_path_len);\n            if (old_path === 0 || new_path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const wasi = _wasi.get(this);\n            let oldWrap;\n            let newWrap;\n            if (old_fd === new_fd) {\n                oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE | WasiRights.PATH_LINK_TARGET, BigInt(0));\n            }\n            else {\n                oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE, BigInt(0));\n                newWrap = wasi.fds.get(new_fd, WasiRights.PATH_LINK_TARGET, BigInt(0));\n            }\n            const { HEAPU8 } = getMemory(this);\n            const fs = getFs(this);\n            const resolvedOldPath = resolvePathSync(fs, oldWrap, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)), old_flags);\n            const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len)));\n            fs.linkSync(resolvedOldPath, resolvedNewPath);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function path_link(old_fd, old_flags, old_path, old_path_len, new_fd, new_path, new_path_len) {\n            old_path = Number(old_path);\n            old_path_len = Number(old_path_len);\n            new_path = Number(new_path);\n            new_path_len = Number(new_path_len);\n            if (old_path === 0 || new_path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const wasi = _wasi.get(this);\n            let oldWrap;\n            let newWrap;\n            if (old_fd === new_fd) {\n                oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE | WasiRights.PATH_LINK_TARGET, BigInt(0));\n            }\n            else {\n                oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_LINK_SOURCE, BigInt(0));\n                newWrap = wasi.fds.get(new_fd, WasiRights.PATH_LINK_TARGET, BigInt(0));\n            }\n            const { HEAPU8 } = getMemory(this);\n            const fs = getFs(this);\n            const resolvedOldPath = await resolvePathAsync(fs, oldWrap, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)), old_flags);\n            const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len)));\n            await fs.promises.link(resolvedOldPath, resolvedNewPath);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i32', 'i32'], ['i32']);\n        function pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags) {\n            const read = (fs_rights_base & (WasiRights.FD_READ |\n                WasiRights.FD_READDIR)) !== BigInt(0);\n            const write = (fs_rights_base & (WasiRights.FD_DATASYNC |\n                WasiRights.FD_WRITE |\n                WasiRights.FD_ALLOCATE |\n                WasiRights.FD_FILESTAT_SET_SIZE)) !== BigInt(0);\n            let flags = write ? read ? 2 /* FileControlFlag.O_RDWR */ : 1 /* FileControlFlag.O_WRONLY */ : 0 /* FileControlFlag.O_RDONLY */;\n            let needed_base = WasiRights.PATH_OPEN;\n            let needed_inheriting = fs_rights_base | fs_rights_inheriting;\n            if ((o_flags & 1 /* WasiFileControlFlag.O_CREAT */) !== 0) {\n                flags |= 64 /* FileControlFlag.O_CREAT */;\n                needed_base |= WasiRights.PATH_CREATE_FILE;\n            }\n            if ((o_flags & 2 /* WasiFileControlFlag.O_DIRECTORY */) !== 0) {\n                flags |= 65536 /* FileControlFlag.O_DIRECTORY */;\n            }\n            if ((o_flags & 4 /* WasiFileControlFlag.O_EXCL */) !== 0) {\n                flags |= 128 /* FileControlFlag.O_EXCL */;\n            }\n            if ((o_flags & 8 /* WasiFileControlFlag.O_TRUNC */) !== 0) {\n                flags |= 512 /* FileControlFlag.O_TRUNC */;\n                needed_base |= WasiRights.PATH_FILESTAT_SET_SIZE;\n            }\n            if ((fs_flags & 1 /* WasiFdFlag.APPEND */) !== 0) {\n                flags |= 1024 /* FileControlFlag.O_APPEND */;\n            }\n            if ((fs_flags & 2 /* WasiFdFlag.DSYNC */) !== 0) {\n                // flags |= FileControlFlag.O_DSYNC;\n                needed_inheriting |= WasiRights.FD_DATASYNC;\n            }\n            if ((fs_flags & 4 /* WasiFdFlag.NONBLOCK */) !== 0) {\n                flags |= 2048 /* FileControlFlag.O_NONBLOCK */;\n            }\n            if ((fs_flags & 8 /* WasiFdFlag.RSYNC */) !== 0) {\n                flags |= 1052672 /* FileControlFlag.O_SYNC */;\n                needed_inheriting |= WasiRights.FD_SYNC;\n            }\n            if ((fs_flags & 16 /* WasiFdFlag.SYNC */) !== 0) {\n                flags |= 1052672 /* FileControlFlag.O_SYNC */;\n                needed_inheriting |= WasiRights.FD_SYNC;\n            }\n            if (write && (flags & (1024 /* FileControlFlag.O_APPEND */ | 512 /* FileControlFlag.O_TRUNC */)) === 0) {\n                needed_inheriting |= WasiRights.FD_SEEK;\n            }\n            return { flags, needed_base, needed_inheriting };\n        }\n        defineImport('path_open', function path_open(dirfd, dirflags, path, path_len, o_flags, fs_rights_base, fs_rights_inheriting, fs_flags, fd) {\n            path = Number(path);\n            fd = Number(fd);\n            if (path === 0 || fd === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            path_len = Number(path_len);\n            fs_rights_base = BigInt(fs_rights_base);\n            fs_rights_inheriting = BigInt(fs_rights_inheriting);\n            const { flags: flagsRes, needed_base: neededBase, needed_inheriting: neededInheriting } = pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(dirfd, neededBase, neededInheriting);\n            const memory = getMemory(this);\n            const HEAPU8 = memory.HEAPU8;\n            const pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            const fs = getFs(this);\n            const resolved_path = resolvePathSync(fs, fileDescriptor, pathString, dirflags);\n            const r = fs.openSync(resolved_path, flagsRes, 0o666);\n            const filetype = wasi.fds.getFileTypeByFd(r);\n            if ((o_flags & 2 /* WasiFileControlFlag.O_DIRECTORY */) !== 0 && filetype !== 3 /* WasiFileType.DIRECTORY */) {\n                return 54 /* WasiErrno.ENOTDIR */;\n            }\n            const { base: max_base, inheriting: max_inheriting } = getRights(wasi.fds.stdio, r, flagsRes, filetype);\n            const wrap = wasi.fds.insert(r, resolved_path, resolved_path, filetype, fs_rights_base & max_base, fs_rights_inheriting & max_inheriting, 0);\n            const stat = fs.fstatSync(r, { bigint: true });\n            if (stat.isFile()) {\n                wrap.size = stat.size;\n                if ((flagsRes & 1024 /* FileControlFlag.O_APPEND */) !== 0) {\n                    wrap.pos = stat.size;\n                }\n            }\n            const view = memory.view;\n            view.setInt32(fd, wrap.id, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function path_open(dirfd, dirflags, path, path_len, o_flags, fs_rights_base, fs_rights_inheriting, fs_flags, fd) {\n            path = Number(path);\n            fd = Number(fd);\n            if (path === 0 || fd === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            path_len = Number(path_len);\n            fs_rights_base = BigInt(fs_rights_base);\n            fs_rights_inheriting = BigInt(fs_rights_inheriting);\n            const { flags: flagsRes, needed_base: neededBase, needed_inheriting: neededInheriting } = pathOpen(o_flags, fs_rights_base, fs_rights_inheriting, fs_flags);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(dirfd, neededBase, neededInheriting);\n            const memory = getMemory(this);\n            const HEAPU8 = memory.HEAPU8;\n            const pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            const fs = getFs(this);\n            const resolved_path = await resolvePathAsync(fs, fileDescriptor, pathString, dirflags);\n            const r = await fs.promises.open(resolved_path, flagsRes, 0o666);\n            const filetype = await wasi.fds.getFileTypeByFd(r);\n            if ((o_flags & 2 /* WasiFileControlFlag.O_DIRECTORY */) !== 0 && filetype !== 3 /* WasiFileType.DIRECTORY */) {\n                return 54 /* WasiErrno.ENOTDIR */;\n            }\n            const { base: max_base, inheriting: max_inheriting } = getRights(wasi.fds.stdio, r.fd, flagsRes, filetype);\n            const wrap = wasi.fds.insert(r, resolved_path, resolved_path, filetype, fs_rights_base & max_base, fs_rights_inheriting & max_inheriting, 0);\n            const stat = await r.stat({ bigint: true });\n            if (stat.isFile()) {\n                wrap.size = stat.size;\n                if ((flagsRes & 1024 /* FileControlFlag.O_APPEND */) !== 0) {\n                    wrap.pos = stat.size;\n                }\n            }\n            const view = memory.view;\n            view.setInt32(fd, wrap.id, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i64', 'i64', 'i32', 'i32'], ['i32']);\n        defineImport('path_readlink', function path_readlink(fd, path, path_len, buf, buf_len, bufused) {\n            path = Number(path);\n            path_len = Number(path_len);\n            buf = Number(buf);\n            buf_len = Number(buf_len);\n            bufused = Number(bufused);\n            if (path === 0 || buf === 0 || bufused === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_READLINK, BigInt(0));\n            let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            pathString = resolve(fileDescriptor.realPath, pathString);\n            const fs = getFs(this);\n            const link = fs.readlinkSync(pathString);\n            const linkData = encoder.encode(link);\n            const len = Math.min(linkData.length, buf_len);\n            if (len >= buf_len)\n                return 42 /* WasiErrno.ENOBUFS */;\n            HEAPU8.set(linkData.subarray(0, len), buf);\n            HEAPU8[buf + len] = 0;\n            view.setUint32(bufused, len, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function path_readlink(fd, path, path_len, buf, buf_len, bufused) {\n            path = Number(path);\n            path_len = Number(path_len);\n            buf = Number(buf);\n            buf_len = Number(buf_len);\n            bufused = Number(bufused);\n            if (path === 0 || buf === 0 || bufused === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8, view } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_READLINK, BigInt(0));\n            let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            pathString = resolve(fileDescriptor.realPath, pathString);\n            const fs = getFs(this);\n            const link = await fs.promises.readlink(pathString);\n            const linkData = encoder.encode(link);\n            const len = Math.min(linkData.length, buf_len);\n            if (len >= buf_len)\n                return 42 /* WasiErrno.ENOBUFS */;\n            HEAPU8.set(linkData.subarray(0, len), buf);\n            HEAPU8[buf + len] = 0;\n            view.setUint32(bufused, len, true);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i32'], ['i32']);\n        defineImport('path_remove_directory', function path_remove_directory(fd, path, path_len) {\n            path = Number(path);\n            path_len = Number(path_len);\n            if (path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8 } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_REMOVE_DIRECTORY, BigInt(0));\n            let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            pathString = resolve(fileDescriptor.realPath, pathString);\n            const fs = getFs(this);\n            fs.rmdirSync(pathString);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function path_remove_directory(fd, path, path_len) {\n            path = Number(path);\n            path_len = Number(path_len);\n            if (path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8 } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_REMOVE_DIRECTORY, BigInt(0));\n            let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            pathString = resolve(fileDescriptor.realPath, pathString);\n            const fs = getFs(this);\n            await fs.promises.rmdir(pathString);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32'], ['i32']);\n        defineImport('path_rename', function path_rename(old_fd, old_path, old_path_len, new_fd, new_path, new_path_len) {\n            old_path = Number(old_path);\n            old_path_len = Number(old_path_len);\n            new_path = Number(new_path);\n            new_path_len = Number(new_path_len);\n            if (old_path === 0 || new_path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const wasi = _wasi.get(this);\n            let oldWrap;\n            let newWrap;\n            if (old_fd === new_fd) {\n                oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE | WasiRights.PATH_RENAME_TARGET, BigInt(0));\n            }\n            else {\n                oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE, BigInt(0));\n                newWrap = wasi.fds.get(new_fd, WasiRights.PATH_RENAME_TARGET, BigInt(0));\n            }\n            const { HEAPU8 } = getMemory(this);\n            const resolvedOldPath = resolve(oldWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)));\n            const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len)));\n            const fs = getFs(this);\n            fs.renameSync(resolvedOldPath, resolvedNewPath);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function path_rename(old_fd, old_path, old_path_len, new_fd, new_path, new_path_len) {\n            old_path = Number(old_path);\n            old_path_len = Number(old_path_len);\n            new_path = Number(new_path);\n            new_path_len = Number(new_path_len);\n            if (old_path === 0 || new_path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const wasi = _wasi.get(this);\n            let oldWrap;\n            let newWrap;\n            if (old_fd === new_fd) {\n                oldWrap = newWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE | WasiRights.PATH_RENAME_TARGET, BigInt(0));\n            }\n            else {\n                oldWrap = wasi.fds.get(old_fd, WasiRights.PATH_RENAME_SOURCE, BigInt(0));\n                newWrap = wasi.fds.get(new_fd, WasiRights.PATH_RENAME_TARGET, BigInt(0));\n            }\n            const { HEAPU8 } = getMemory(this);\n            const resolvedOldPath = resolve(oldWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len)));\n            const resolvedNewPath = resolve(newWrap.realPath, decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len)));\n            const fs = getFs(this);\n            await fs.promises.rename(resolvedOldPath, resolvedNewPath);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i32', 'i32', 'i32'], ['i32']);\n        defineImport('path_symlink', function path_symlink(old_path, old_path_len, fd, new_path, new_path_len) {\n            old_path = Number(old_path);\n            old_path_len = Number(old_path_len);\n            new_path = Number(new_path);\n            new_path_len = Number(new_path_len);\n            if (old_path === 0 || new_path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8 } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_SYMLINK, BigInt(0));\n            const oldPath = decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len));\n            let newPath = decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len));\n            newPath = resolve(fileDescriptor.realPath, newPath);\n            const fs = getFs(this);\n            fs.symlinkSync(oldPath, newPath);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function path_symlink(old_path, old_path_len, fd, new_path, new_path_len) {\n            old_path = Number(old_path);\n            old_path_len = Number(old_path_len);\n            new_path = Number(new_path);\n            new_path_len = Number(new_path_len);\n            if (old_path === 0 || new_path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8 } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_SYMLINK, BigInt(0));\n            const oldPath = decoder.decode(unsharedSlice(HEAPU8, old_path, old_path + old_path_len));\n            let newPath = decoder.decode(unsharedSlice(HEAPU8, new_path, new_path + new_path_len));\n            newPath = resolve(fileDescriptor.realPath, newPath);\n            const fs = getFs(this);\n            await fs.promises.symlink(oldPath, newPath);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32', 'i32', 'i32'], ['i32']);\n        defineImport('path_unlink_file', function path_unlink_file(fd, path, path_len) {\n            path = Number(path);\n            path_len = Number(path_len);\n            if (path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8 } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_UNLINK_FILE, BigInt(0));\n            let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            pathString = resolve(fileDescriptor.realPath, pathString);\n            const fs = getFs(this);\n            fs.unlinkSync(pathString);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, async function path_unlink_file(fd, path, path_len) {\n            path = Number(path);\n            path_len = Number(path_len);\n            if (path === 0) {\n                return 28 /* WasiErrno.EINVAL */;\n            }\n            const { HEAPU8 } = getMemory(this);\n            const wasi = _wasi.get(this);\n            const fileDescriptor = wasi.fds.get(fd, WasiRights.PATH_UNLINK_FILE, BigInt(0));\n            let pathString = decoder.decode(unsharedSlice(HEAPU8, path, path + path_len));\n            pathString = resolve(fileDescriptor.realPath, pathString);\n            const fs = getFs(this);\n            await fs.promises.unlink(pathString);\n            return 0 /* WasiErrno.ESUCCESS */;\n        }, ['i32', 'i32', 'i32'], ['i32']);\n        this._setMemory = function setMemory(m) {\n            if (!(m instanceof _WebAssembly.Memory)) {\n                throw new TypeError('\"instance.exports.memory\" property must be a WebAssembly.Memory');\n            }\n            _memory.set(_this, extendMemory(m));\n        };\n    }\n    static createSync(args, env, preopens, stdio, fs, print, printErr) {\n        const fds = new SyncTable({\n            size: 3,\n            in: stdio[0],\n            out: stdio[1],\n            err: stdio[2],\n            fs,\n            print,\n            printErr\n        });\n        const _this = new WASI$1(args, env, fds, false, fs);\n        if (preopens.length > 0) {\n            for (let i = 0; i < preopens.length; ++i) {\n                const realPath = fs.realpathSync(preopens[i].realPath, 'utf8');\n                const fd = fs.openSync(realPath, 'r', 0o666);\n                fds.insertPreopen(fd, preopens[i].mappedPath, realPath);\n            }\n        }\n        return _this;\n    }\n    static async createAsync(args, env, preopens, stdio, fs, print, printErr, asyncify) {\n        const fds = new AsyncTable({\n            size: 3,\n            in: stdio[0],\n            out: stdio[1],\n            err: stdio[2],\n            print,\n            printErr\n        });\n        const _this = new WASI$1(args, env, fds, true, fs, asyncify);\n        if (preopens.length > 0) {\n            for (let i = 0; i < preopens.length; ++i) {\n                const entry = preopens[i];\n                const realPath = await fs.promises.realpath(entry.realPath);\n                const fd = await fs.promises.open(realPath, 'r', 0o666);\n                await fds.insertPreopen(fd, entry.mappedPath, realPath);\n            }\n        }\n        return _this;\n    }\n}\n\n// eslint-disable-next-line spaced-comment\nconst kEmptyObject = /*#__PURE__*/ Object.freeze(/*#__PURE__*/ Object.create(null));\nconst kExitCode = Symbol('kExitCode');\nconst kSetMemory = Symbol('kSetMemory');\nconst kStarted = Symbol('kStarted');\nconst kInstance = Symbol('kInstance');\nconst kBindingName = Symbol('kBindingName');\nfunction setupInstance(self, instance) {\n    validateObject(instance, 'instance');\n    validateObject(instance.exports, 'instance.exports');\n    self[kInstance] = instance;\n    self[kSetMemory](instance.exports.memory);\n}\nfunction validateOptions(options) {\n    var _a;\n    validateObject(options, 'options');\n    let _WASI;\n    if (options.version !== undefined) {\n        validateString(options.version, 'options.version');\n        switch (options.version) {\n            case 'unstable':\n                _WASI = WASI$1;\n                this[kBindingName] = 'wasi_unstable';\n                break;\n            case 'preview1':\n                _WASI = WASI$1;\n                this[kBindingName] = 'wasi_snapshot_preview1';\n                break;\n            default:\n                throw new TypeError(`unsupported WASI version \"${options.version}\"`);\n        }\n    }\n    else {\n        _WASI = WASI$1;\n        this[kBindingName] = 'wasi_snapshot_preview1';\n    }\n    if (options.args !== undefined) {\n        validateArray(options.args, 'options.args');\n    }\n    const args = ((_a = options.args) !== null && _a !== void 0 ? _a : []).map(String);\n    const env = [];\n    if (options.env !== undefined) {\n        validateObject(options.env, 'options.env');\n        Object.entries(options.env).forEach(({ 0: key, 1: value }) => {\n            if (value !== undefined) {\n                env.push(`${key}=${value}`);\n            }\n        });\n    }\n    const preopens = [];\n    if (options.preopens !== undefined) {\n        validateObject(options.preopens, 'options.preopens');\n        Object.entries(options.preopens).forEach(({ 0: key, 1: value }) => preopens.push({ mappedPath: String(key), realPath: String(value) }));\n    }\n    if (preopens.length > 0) {\n        if (options.fs === undefined) {\n            throw new Error('filesystem is disabled, can not preopen directory');\n        }\n        try {\n            validateObject(options.fs, 'options.fs');\n        }\n        catch (_) {\n            throw new TypeError('Node.js fs like implementation is not provided');\n        }\n    }\n    // if (options.filesystem !== undefined) {\n    //   validateObject(options.filesystem, 'options.filesystem')\n    //   validateString(options.filesystem.type, 'options.filesystem.type')\n    //   if (options.filesystem.type !== 'memfs' && options.filesystem.type !== 'file-system-access-api') {\n    //     throw new Error(`Filesystem type ${(options.filesystem as any).type as string} is not supported, only \"memfs\" and \"file-system-access-api\" is supported currently`)\n    //   }\n    //   try {\n    //     validateObject(options.filesystem.fs, 'options.filesystem.fs')\n    //   } catch (_) {\n    //     throw new Error('Node.js fs like implementation is not provided')\n    //   }\n    // }\n    if (options.print !== undefined)\n        validateFunction(options.print, 'options.print');\n    if (options.printErr !== undefined)\n        validateFunction(options.printErr, 'options.printErr');\n    if (options.returnOnExit !== undefined) {\n        validateBoolean(options.returnOnExit, 'options.returnOnExit');\n    }\n    // const { stdin = 0, stdout = 1, stderr = 2 } = options\n    // validateInt32(stdin, 'options.stdin', 0)\n    // validateInt32(stdout, 'options.stdout', 0)\n    // validateInt32(stderr, 'options.stderr', 0)\n    // const stdio = [stdin, stdout, stderr] as const\n    const stdio = [0, 1, 2];\n    return {\n        args,\n        env,\n        preopens,\n        stdio,\n        _WASI\n    };\n}\nfunction initWASI(setMemory, wrap) {\n    this[kSetMemory] = setMemory;\n    this.wasiImport = wrap;\n    this[kStarted] = false;\n    this[kExitCode] = 0;\n    this[kInstance] = undefined;\n}\n/** @public */\nclass WASI {\n    constructor(options = kEmptyObject) {\n        const { args, env, preopens, stdio, _WASI } = validateOptions.call(this, options);\n        const wrap = _WASI.createSync(args, env, preopens, stdio, options.fs, options.print, options.printErr);\n        const setMemory = wrap._setMemory;\n        delete wrap._setMemory;\n        initWASI.call(this, setMemory, wrap);\n        if (options.returnOnExit) {\n            wrap.proc_exit = wasiReturnOnProcExit.bind(this);\n        }\n    }\n    // Must not export _initialize, must export _start\n    start(instance) {\n        if (this[kStarted]) {\n            throw new Error('WASI instance has already started');\n        }\n        this[kStarted] = true;\n        setupInstance(this, instance);\n        const { _start, _initialize } = this[kInstance].exports;\n        validateFunction(_start, 'instance.exports._start');\n        validateUndefined(_initialize, 'instance.exports._initialize');\n        let ret;\n        try {\n            ret = _start();\n        }\n        catch (err) {\n            if (err !== kExitCode) {\n                throw err;\n            }\n        }\n        if (ret instanceof Promise) {\n            return ret.then(() => this[kExitCode], (err) => {\n                if (err !== kExitCode) {\n                    throw err;\n                }\n                return this[kExitCode];\n            });\n        }\n        return this[kExitCode];\n    }\n    // Must not export _start, may optionally export _initialize\n    initialize(instance) {\n        if (this[kStarted]) {\n            throw new Error('WASI instance has already started');\n        }\n        this[kStarted] = true;\n        setupInstance(this, instance);\n        const { _start, _initialize } = this[kInstance].exports;\n        validateUndefined(_start, 'instance.exports._start');\n        if (_initialize !== undefined) {\n            validateFunction(_initialize, 'instance.exports._initialize');\n            return _initialize();\n        }\n    }\n    getImportObject() {\n        return { [this[kBindingName]]: this.wasiImport };\n    }\n}\nfunction wasiReturnOnProcExit(rval) {\n    this[kExitCode] = rval;\n    // eslint-disable-next-line @typescript-eslint/no-throw-literal\n    throw kExitCode;\n}\n/** @public */\nasync function createAsyncWASI(options = kEmptyObject) {\n    const _this = Object.create(WASI.prototype);\n    const { args, env, preopens, stdio, _WASI } = validateOptions.call(_this, options);\n    if (options.asyncify !== undefined) {\n        validateObject(options.asyncify, 'options.asyncify');\n        validateFunction(options.asyncify.wrapImportFunction, 'options.asyncify.wrapImportFunction');\n    }\n    const wrap = await _WASI.createAsync(args, env, preopens, stdio, options.fs, options.print, options.printErr, options.asyncify);\n    const setMemory = wrap._setMemory;\n    delete wrap._setMemory;\n    initWASI.call(_this, setMemory, wrap);\n    if (options.returnOnExit) {\n        wrap.proc_exit = wasiReturnOnProcExit.bind(_this);\n    }\n    return _this;\n}\n\nexport { Asyncify, Memory, WASI, WebAssemblyMemory, asyncifyLoad, asyncifyLoadSync, createAsyncWASI, extendMemory, load, loadSync, wrapAsyncExport, wrapAsyncImport, wrapExports };\n","// @ts-check\n\n/**\n * @param {unknown} value\n */\nconst getType = (value) => {\n  if (value === undefined) return 0\n  if (value === null) return 1\n  const t = typeof value\n  if (t === 'boolean') return 2\n  if (t === 'number') return 3\n  if (t === 'string') return 4\n  if (t === 'object') return 6\n  if (t === 'bigint') return 9\n  return -1\n}\n\n/**\n * @param {import('memfs').IFs} memfs\n * @param {any} value\n * @param {ReturnType<typeof getType>} type\n * @returns {Uint8Array}\n */\nconst encodeValue = (memfs, value, type) => {\n  switch (type) {\n    case 0:\n    case 1:\n      return new Uint8Array(0)\n    case 2: {\n      const view = new Int32Array(1)\n      view[0] = value ? 1 : 0\n      return new Uint8Array(view.buffer)\n    }\n    case 3: {\n      const view = new Float64Array(1)\n      view[0] = value\n      return new Uint8Array(view.buffer)\n    }\n    case 4: {\n      const view = new TextEncoder().encode(value)\n      return view\n    }\n    case 6: {\n      const [entry] = Object.entries(memfs).filter(([_, v]) => v === value.constructor)[0] ?? []\n      if (entry) {\n        Object.defineProperty(value, '__constructor__', {\n          configurable: true,\n          writable: true,\n          enumerable: true,\n          value: entry\n        })\n      }\n\n      const json = JSON.stringify(value, (_, value) => {\n        if (typeof value === 'bigint') {\n          return `BigInt(${String(value)})`\n        }\n        return value\n      })\n      const view = new TextEncoder().encode(json)\n      return view\n    }\n    case 9: {\n      const view = new BigInt64Array(1)\n      view[0] = value\n      return new Uint8Array(view.buffer)\n    }\n    case -1:\n    default:\n      throw new Error('unsupported data')\n  }\n}\n\n/**\n * @param {import('memfs').IFs} fs\n * @returns {(e: { data: { __fs__: { sab: Int32Array, type: keyof import('memfs').IFs, payload: any[] } } }) => void}\n */\nmodule.exports.createOnMessage = (fs) => function onMessage(e) {\n  if (e.data.__fs__) {\n    /**\n     * 0..4                    status(int32_t):        21(waiting) 0(success) 1(error)\n     * 5..8                    type(napi_valuetype):   0(undefined) 1(null) 2(boolean) 3(number) 4(string) 6(jsonstring) 9(bigint) -1(unsupported)\n     * 9..16                   payload_size(uint32_t)  <= 1024\n     * 16..16 + payload_size   payload_content\n     */\n    const { sab, type, payload } = e.data.__fs__\n    const fn = fs[type]\n    const args = payload ? payload.map((value) => {\n      if (value instanceof Uint8Array) {\n        // buffer polyfill bug\n        // @ts-expect-error\n        value._isBuffer = true\n      }\n      return value\n    }) : payload\n    try {\n      const ret = fn.apply(fs, args)\n      const t = getType(ret)\n      const v = encodeValue(fs, ret, t)\n      Atomics.store(sab, 0, 0)\n      Atomics.store(sab, 1, t)\n      Atomics.store(sab, 2, v.length)\n      new Uint8Array(sab.buffer).set(v, 16)\n\n    } catch (/** @type {any} */ err) {\n      Atomics.store(sab, 0, 1)\n      Atomics.store(sab, 1, 6)\n      const payloadContent = new TextEncoder().encode(JSON.stringify({\n        ...err,\n        message: err.message,\n        stack: err.stack\n      }))\n      Atomics.store(sab, 2, payloadContent.length)\n      new Uint8Array(sab.buffer).set(payloadContent, 16)\n    } finally {\n      Atomics.notify(sab, 0)\n    }\n  }\n}\n\n/**\n * @param {import('memfs').IFs} memfs\n */\nmodule.exports.createFsProxy = (memfs) => new Proxy({}, {\n  get (_target, p, _receiver) {\n    /**\n     * @param {any[]} args\n     */\n    return function (...args) {\n      const sab = new SharedArrayBuffer(16 + 1024)\n      const i32arr = new Int32Array(sab)\n      Atomics.store(i32arr, 0, 21)\n\n      // @ts-expect-error\n      postMessage({\n        __fs__: {\n          sab: i32arr,\n          type: p,\n          payload: args\n        }\n      })\n\n      Atomics.wait(i32arr, 0, 21)\n\n      const status = Atomics.load(i32arr, 0)\n      const type = Atomics.load(i32arr, 1)\n      const size = Atomics.load(i32arr, 2)\n      const content = new Uint8Array(sab, 16, size)\n      if (status === 1) {\n        const errobj = JSON.parse(new TextDecoder().decode(content.slice()))\n        const err = new Error(errobj.message)\n        Object.defineProperty(err, 'stack', {\n          configurable: true,\n          enumerable: false,\n          writable: true,\n          value: errobj.stack\n        })\n        for (const [k, v] of Object.entries(errobj)) {\n          if (k === 'message' || k === 'stack') continue\n          // @ts-expect-error\n          err[k] = v\n        }\n        throw err\n      }\n      if (type === 0) return undefined\n      if (type === 1) return null\n      if (type === 2) return Boolean(content[0])\n      if (type === 3) return new Float64Array(sab, 16, 1)[0]\n      if (type === 4) return new TextDecoder().decode(content.slice())\n      if (type === 6) {\n        const obj = JSON.parse(new TextDecoder().decode(content.slice()), (_key, value) => {\n          if (typeof value === 'string') {\n            const matched = value.match(/^BigInt\\((-?\\d+)\\)$/)\n            if (matched && matched[1]) {\n              return BigInt(matched[1])\n            }\n          }\n          return value\n        })\n        if (obj.__constructor__) {\n          const ctor = obj.__constructor__\n          delete obj.__constructor__\n          // @ts-expect-error\n          Object.setPrototypeOf(obj, memfs[ctor].prototype)\n        }\n        return obj\n      }\n      if (type === 9) return new BigInt64Array(sab, 16, 1)[0]\n      throw new Error('unsupported data')\n    }\n  }\n})\n"],"names":["_WebAssembly"],"mappings":"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","x_google_ignoreList":[0,1,2,3]} diff --git a/samples/Javascript/clean/napi_rs_runtime.js.simple b/samples/Javascript/clean/napi_rs_runtime.js.simple new file mode 100644 index 000000000..abdf08619 --- /dev/null +++ b/samples/Javascript/clean/napi_rs_runtime.js.simple @@ -0,0 +1,21 @@ +# Javascript/clean/napi_rs_runtime.js +data/embedded/base64/terms +data/embedded/base64/url +encoding/base64 +encoding/json/decode +encoding/json/encode +fd/write +fs/directory/create +fs/directory/list +fs/directory/remove +fs/file/delete +fs/file/stat +fs/file/times/set +fs/link/read +fs/symlink/resolve +kernel/sysinfo +net/socket/listen +net/socket/receive +net/socket/send +ref/site/url +ref/words/exclamation