@tailwindcss/oxide-wasm32-wasi 0.0.0-insiders.d801d8d

package/node_modules/@emnapi/runtime/dist/emnapi.esm-bundler.js

@@ -0,0 +1,1403 @@
+import { __extends } from 'tslib';
+
+var externalValue = new WeakMap();
+/** @public */
+function isExternal(object) {
+    return externalValue.has(object);
+}
+/** @public */ // eslint-disable-next-line @typescript-eslint/no-redeclare
+var External = (function () {
+    function External(value) {
+        Object.setPrototypeOf(this, null);
+        externalValue.set(this, value);
+    }
+    External.prototype = null;
+    return External;
+})();
+/** @public */
+function getExternalValue(external) {
+    if (!isExternal(external)) {
+        throw new TypeError('not external');
+    }
+    return externalValue.get(external);
+}
+
+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 __webpack_public_path__ === 'undefined') {
+            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;
+    if (typeof __webpack_public_path__ !== 'undefined') {
+        nativeRequire = (function () {
+            return typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : undefined;
+        })();
+    }
+    else {
+        nativeRequire = (function () {
+            return typeof __webpack_public_path__ !== 'undefined' ? (typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : undefined) : (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.4.0";
+var NODE_API_SUPPORTED_VERSION_MIN = 1 /* Version.NODE_API_SUPPORTED_VERSION_MIN */;
+var NODE_API_SUPPORTED_VERSION_MAX = 10 /* 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 () {
+        return getExternalValue(this.value);
+    };
+    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 isExternal(this.value);
+    };
+    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 (BufferConstructor) {
+        if (ArrayBuffer.isView(this.value))
+            return true;
+        BufferConstructor !== null && BufferConstructor !== void 0 ? BufferConstructor : (BufferConstructor = _Buffer);
+        return typeof BufferConstructor === 'function' && BufferConstructor.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));
+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;
+        this.callbackInfo = {
+            thiz: undefined,
+            data: 0,
+            args: undefined,
+            fn: undefined
+        };
+    }
+    HandleScope.prototype.add = function (value) {
+        var h = this.handleStore.push(value);
+        this.end++;
+        return h;
+    };
+    HandleScope.prototype.addExternal = function (data) {
+        return this.add(new External(data));
+    };
+    HandleScope.prototype.dispose = function () {
+        if (this._escapeCalled)
+            this._escapeCalled = false;
+        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;
+        this._values = [undefined];
+    }
+    ScopeStore.prototype.get = function (id) {
+        return this._values[id];
+    };
+    ScopeStore.prototype.openScope = function (envObject) {
+        var currentScope = this.currentScope;
+        var scope = currentScope.child;
+        if (scope !== null) {
+            scope.start = scope.end = currentScope.end;
+        }
+        else {
+            var id = currentScope.id + 1;
+            scope = new HandleScope(envObject.ctx.handleStore, id, currentScope, currentScope.end);
+            this._values[id] = scope;
+        }
+        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 () {
+        this.currentScope = this._rootScope;
+        this._values.length = 1;
+    };
+    return ScopeStore;
+}());
+
+var RefTracker = /*#__PURE__*/ (function () {
+    function RefTracker() {
+        this._next = null;
+        this._prev = null;
+    }
+    /** @virtual */
+    RefTracker.prototype.dispose = function () { };
+    /** @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;
+        this._makeDynCall_vppp = envObject.makeDynCall_vppp;
+    }
+    Finalizer.prototype.callback = function () { return this._finalizeCallback; };
+    Finalizer.prototype.data = function () { return this._finalizeData; };
+    Finalizer.prototype.hint = function () { return this._finalizeHint; };
+    Finalizer.prototype.resetEnv = function () {
+        this.envObject = undefined;
+    };
+    Finalizer.prototype.resetFinalizer = function () {
+        this._finalizeCallback = 0;
+        this._finalizeData = 0;
+        this._finalizeHint = 0;
+    };
+    Finalizer.prototype.callFinalizer = function () {
+        var finalize_callback = this._finalizeCallback;
+        var finalize_data = this._finalizeData;
+        var finalize_hint = this._finalizeHint;
+        this.resetFinalizer();
+        if (!finalize_callback)
+            return;
+        var fini = Number(finalize_callback);
+        if (!this.envObject) {
+            this._makeDynCall_vppp(fini)(0, finalize_data, finalize_hint);
+        }
+        else {
+            this.envObject.callFinalizer(fini, finalize_data, finalize_hint);
+        }
+    };
+    Finalizer.prototype.dispose = function () {
+        this.envObject = undefined;
+        this._makeDynCall_vppp = 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) || this;
+        _this._finalizer = new Finalizer(envObject, finalize_callback, finalize_data, finalize_hint);
+        return _this;
+    }
+    TrackedFinalizer.create = function (envObject, finalize_callback, finalize_data, finalize_hint) {
+        var finalizer = new TrackedFinalizer(envObject, finalize_callback, finalize_data, finalize_hint);
+        finalizer.link(envObject.finalizing_reflist);
+        return finalizer;
+    };
+    TrackedFinalizer.prototype.data = function () {
+        return this._finalizer.data();
+    };
+    TrackedFinalizer.prototype.dispose = function () {
+        if (!this._finalizer)
+            return;
+        this.unlink();
+        this._finalizer.envObject.dequeueFinalizer(this);
+        this._finalizer.dispose();
+        this._finalizer = undefined;
+        _super.prototype.dispose.call(this);
+    };
+    TrackedFinalizer.prototype.finalize = function () {
+        this.unlink();
+        var error;
+        var caught = false;
+        try {
+            this._finalizer.callFinalizer();
+        }
+        catch (err) {
+            caught = true;
+            error = err;
+        }
+        this.dispose();
+        if (caught) {
+            throw error;
+        }
+    };
+    return TrackedFinalizer;
+}(RefTracker));
+
+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;
+    };
+    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 () {
+        RefTracker.finalizeAll(this.finalizing_reflist);
+        RefTracker.finalizeAll(this.reflist);
+        this.tryCatch.extractException();
+        this.ctx.envStore.remove(this.id);
+    };
+    Env.prototype.dispose = function () {
+        if (this.id === 0)
+            return;
+        this.deleteMe();
+        this.finalizing_reflist.dispose();
+        this.reflist.dispose();
+        this.id = 0;
+    };
+    Env.prototype.initObjectBinding = function (value) {
+        var binding = {
+            wrapped: 0,
+            tag: null
+        };
+        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 = TrackedFinalizer.create(this, 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 {
+            if (typeof process === 'object' && process !== null && typeof process._fatalException === 'function') {
+                var handled = process._fatalException(err);
+                if (!handled) {
+                    console.error(err);
+                    process.exit(1);
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    };
+    NodeEnv.prototype.callbackIntoModule = function (enforceUncaughtExceptionPolicy, fn) {
+        return this.callIntoModule(fn, function (envObject, err) {
+            if (envObject.terminatedOrTerminating()) {
+                return;
+            }
+            var hasProcess = typeof process === 'object' && process !== null;
+            var hasForceFlag = hasProcess ? Boolean(process.execArgv && (process.execArgv.indexOf('--force-node-api-uncaught-exceptions-policy') !== -1)) : false;
+            if (envObject.moduleApiVersion < 10 && !hasForceFlag && !enforceUncaughtExceptionPolicy) {
+                var warn = hasProcess && typeof process.emitWarning === 'function'
+                    ? process.emitWarning
+                    : 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;
+}());
+
+var ReferenceOwnership;
+(function (ReferenceOwnership) {
+    ReferenceOwnership[ReferenceOwnership["kRuntime"] = 0] = "kRuntime";
+    ReferenceOwnership[ReferenceOwnership["kUserland"] = 1] = "kUserland";
+})(ReferenceOwnership || (ReferenceOwnership = {}));
+function canBeHeldWeakly(value) {
+    return value.isObject() || value.isFunction() || value.isSymbol();
+}
+var Reference = /*#__PURE__*/ (function (_super) {
+    __extends(Reference, _super);
+    function Reference(envObject, handle_id, initialRefcount, ownership) {
+        var _this = _super.call(this) || this;
+        _this.envObject = envObject;
+        _this._refcount = initialRefcount;
+        _this._ownership = ownership;
+        var handle = envObject.ctx.handleStore.get(handle_id);
+        _this.canBeWeak = canBeHeldWeakly(handle);
+        _this.persistent = new Persistent(handle.value);
+        _this.id = 0;
+        if (initialRefcount === 0) {
+            _this._setWeak();
+        }
+        return _this;
+    }
+    Reference.weakCallback = function (ref) {
+        ref.persistent.reset();
+        ref.invokeFinalizerFromGC();
+    };
+    Reference.create = function (envObject, handle_id, initialRefcount, ownership, _unused1, _unused2, _unused3) {
+        var ref = new Reference(envObject, handle_id, initialRefcount, ownership);
+        envObject.ctx.refStore.add(ref);
+        ref.link(envObject.reflist);
+        return ref;
+    };
+    Reference.prototype.ref = function () {
+        if (this.persistent.isEmpty()) {
+            return 0;
+        }
+        if (++this._refcount === 1 && this.canBeWeak) {
+            this.persistent.clearWeak();
+        }
+        return this._refcount;
+    };
+    Reference.prototype.unref = function () {
+        if (this.persistent.isEmpty() || this._refcount === 0) {
+            return 0;
+        }
+        if (--this._refcount === 0) {
+            this._setWeak();
+        }
+        return this._refcount;
+    };
+    Reference.prototype.get = function (envObject) {
+        if (envObject === void 0) { envObject = this.envObject; }
+        if (this.persistent.isEmpty()) {
+            return 0;
+        }
+        var obj = this.persistent.deref();
+        var handle = envObject.ensureHandle(obj);
+        return handle.id;
+    };
+    /** @virtual */
+    Reference.prototype.resetFinalizer = function () { };
+    /** @virtual */
+    Reference.prototype.data = function () { return 0; };
+    Reference.prototype.refcount = function () { return this._refcount; };
+    Reference.prototype.ownership = function () { return this._ownership; };
+    /** @virtual */
+    Reference.prototype.callUserFinalizer = function () { };
+    /** @virtual */
+    Reference.prototype.invokeFinalizerFromGC = function () {
+        this.finalize();
+    };
+    Reference.prototype._setWeak = function () {
+        if (this.canBeWeak) {
+            this.persistent.setWeak(this, Reference.weakCallback);
+        }
+        else {
+            this.persistent.reset();
+        }
+    };
+    Reference.prototype.finalize = function () {
+        this.persistent.reset();
+        var deleteMe = this._ownership === ReferenceOwnership.kRuntime;
+        this.unlink();
+        this.callUserFinalizer();
+        if (deleteMe) {
+            this.dispose();
+        }
+    };
+    Reference.prototype.dispose = function () {
+        if (this.id === 0)
+            return;
+        this.unlink();
+        this.persistent.reset();
+        this.envObject.ctx.refStore.remove(this.id);
+        _super.prototype.dispose.call(this);
+        this.envObject = undefined;
+        this.id = 0;
+    };
+    return Reference;
+}(RefTracker));
+var ReferenceWithData = /*#__PURE__*/ (function (_super) {
+    __extends(ReferenceWithData, _super);
+    function ReferenceWithData(envObject, value, initialRefcount, ownership, _data) {
+        var _this = _super.call(this, envObject, value, initialRefcount, ownership) || this;
+        _this._data = _data;
+        return _this;
+    }
+    ReferenceWithData.create = function (envObject, value, initialRefcount, ownership, data) {
+        var reference = new ReferenceWithData(envObject, value, initialRefcount, ownership, data);
+        envObject.ctx.refStore.add(reference);
+        reference.link(envObject.reflist);
+        return reference;
+    };
+    ReferenceWithData.prototype.data = function () {
+        return this._data;
+    };
+    return ReferenceWithData;
+}(Reference));
+var ReferenceWithFinalizer = /*#__PURE__*/ (function (_super) {
+    __extends(ReferenceWithFinalizer, _super);
+    function ReferenceWithFinalizer(envObject, value, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) {
+        var _this = _super.call(this, envObject, value, initialRefcount, ownership) || this;
+        _this._finalizer = new Finalizer(envObject, finalize_callback, finalize_data, finalize_hint);
+        return _this;
+    }
+    ReferenceWithFinalizer.create = function (envObject, value, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) {
+        var reference = new ReferenceWithFinalizer(envObject, value, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint);
+        envObject.ctx.refStore.add(reference);
+        reference.link(envObject.finalizing_reflist);
+        return reference;
+    };
+    ReferenceWithFinalizer.prototype.resetFinalizer = function () {
+        this._finalizer.resetFinalizer();
+    };
+    ReferenceWithFinalizer.prototype.data = function () {
+        return this._finalizer.data();
+    };
+    ReferenceWithFinalizer.prototype.callUserFinalizer = function () {
+        this._finalizer.callFinalizer();
+    };
+    ReferenceWithFinalizer.prototype.invokeFinalizerFromGC = function () {
+        this._finalizer.envObject.invokeFinalizerFromGC(this);
+    };
+    ReferenceWithFinalizer.prototype.dispose = function () {
+        if (!this._finalizer)
+            return;
+        this._finalizer.envObject.dequeueFinalizer(this);
+        this._finalizer.dispose();
+        _super.prototype.dispose.call(this);
+        this._finalizer = undefined;
+    };
+    return ReferenceWithFinalizer;
+}(Reference));
+
+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 NodejsWaitingRequestCounter = /*#__PURE__*/ (function () {
+    function NodejsWaitingRequestCounter() {
+        this.refHandle = new _MessageChannel().port1;
+        this.count = 0;
+    }
+    NodejsWaitingRequestCounter.prototype.increase = function () {
+        if (this.count === 0) {
+            this.refHandle.ref();
+        }
+        this.count++;
+    };
+    NodejsWaitingRequestCounter.prototype.decrease = function () {
+        if (this.count === 0)
+            return;
+        if (this.count === 1) {
+            this.refHandle.unref();
+        }
+        this.count--;
+    };
+    return NodejsWaitingRequestCounter;
+}());
+var Context = /*#__PURE__*/ (function () {
+    function Context() {
+        var _this = this;
+        this._isStopping = false;
+        this._canCallIntoJs = true;
+        this._suppressDestroy = false;
+        this.envStore = new Store();
+        this.scopeStore = new ScopeStore();
+        this.refStore = new Store();
+        this.deferredStore = new Store();
+        this.handleStore = new HandleStore();
+        this.feature = {
+            supportReflect: supportReflect,
+            supportFinalizer: supportFinalizer,
+            supportWeakSymbol: supportWeakSymbol,
+            supportBigInt: supportBigInt,
+            supportNewFunction: supportNewFunction,
+            canSetFunctionName: canSetFunctionName,
+            setImmediate: _setImmediate,
+            Buffer: _Buffer,
+            MessageChannel: _MessageChannel
+        };
+        this.cleanupQueue = new CleanupQueue();
+        if (typeof process === 'object' && process !== null && typeof process.once === 'function') {
+            this.refCounter = new NodejsWaitingRequestCounter();
+            process.once('beforeExit', function () {
+                if (!_this._suppressDestroy) {
+                    _this.destroy();
+                }
+            });
+        }
+    }
+    /**
+     * Suppress the destroy on `beforeExit` event in Node.js.
+     * Call this method if you want to keep the context and
+     * all associated {@link Env | Env} alive,
+     * this also means that cleanup hooks will not be called.
+     * After call this method, you should call
+     * {@link Context.destroy | `Context.prototype.destroy`} method manually.
+     */
+    Context.prototype.suppressDestroy = function () {
+        this._suppressDestroy = true;
+    };
+    // 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) {
+        return Reference.create(envObject, handle_id, initialRefcount, ownership);
+    };
+    Context.prototype.createReferenceWithData = function (envObject, handle_id, initialRefcount, ownership, data) {
+        return ReferenceWithData.create(envObject, handle_id, initialRefcount, ownership, data);
+    };
+    Context.prototype.createReferenceWithFinalizer = 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 ReferenceWithFinalizer.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;
+    };
+    /**
+     * Destroy the context and call cleanup hooks.
+     * Associated {@link Env | Env} will be destroyed.
+     */
+    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;
+}
+
+export { ConstHandle, Context, Deferred, EmnapiError, Env, External, 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, RefTracker, Reference, ReferenceOwnership, ReferenceWithData, ReferenceWithFinalizer, ScopeStore, Store, TrackedFinalizer, TryCatch, createContext, getDefaultContext, getExternalValue, isExternal, isReferenceType, version };