nuxt-ai-ready 2.5.0 → 2.5.2

package/node_modules/mdream/node_modules/@emnapi/runtime/dist/emnapi.js

@@ -0,0 +1,2306 @@
+//#region src/util.ts
+function detectFinalizer() {
+    return (typeof FinalizationRegistry !== 'undefined') && (typeof WeakRef !== 'undefined');
+}
+const supportFinalizer = detectFinalizer();
+function detectFeatures(features) {
+    const supportNewFunction = (function () {
+        let f;
+        try {
+            f = new Function();
+        }
+        catch (_) {
+            return false;
+        }
+        return typeof f === 'function';
+    })();
+    const canSetFunctionName = (function () {
+        try {
+            return Boolean(Object.getOwnPropertyDescriptor(Function.prototype, 'name')?.configurable);
+        }
+        catch (_) {
+            return false;
+        }
+    })();
+    const weakSymbol = (function () {
+        try {
+            const sym = Symbol();
+            new WeakRef(sym);
+            new WeakMap().set(sym, undefined);
+        }
+        catch (_) {
+            return false;
+        }
+        return true;
+    })();
+    const _require = (function () {
+        let 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;
+    })();
+    function defaultGetGlobalThis() {
+        if (typeof globalThis !== 'undefined')
+            return globalThis;
+        let 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;
+        }
+        throw new Error('Unable to get globalThis');
+    }
+    function defaultWithResolvers() {
+        let ok;
+        let err;
+        const promise = new this((resolve, reject) => {
+            ok = resolve;
+            err = reject;
+        });
+        return { promise, resolve: ok, reject: err };
+    }
+    const getGlobalThis = features && 'getGlobalThis' in features
+        ? (features.getGlobalThis ?? defaultGetGlobalThis)
+        : defaultGetGlobalThis;
+    const withResolvers = (features && 'withResolvers' in features)
+        ? (features.withResolvers ?? defaultWithResolvers)
+        : typeof Promise.withResolvers === 'function'
+            ? Promise.withResolvers
+            : defaultWithResolvers;
+    const getBuiltinModule = getGlobalThis?.().process?.getBuiltinModule ?? _require;
+    const ret = {
+        makeDynamicFunction: (supportNewFunction
+            ? (...args) => (new Function(...args))
+            : undefined),
+        setFunctionName: (canSetFunctionName
+            ? (f, name) => { Object.defineProperty(f, 'name', { value: name }); }
+            : undefined),
+        Reflect: typeof Reflect === 'object' ? Reflect : undefined,
+        finalizer: detectFinalizer(),
+        weakSymbol,
+        BigInt: typeof BigInt !== 'undefined' ? BigInt : undefined,
+        MessageChannel: typeof MessageChannel === 'function'
+            ? MessageChannel
+            : (function () {
+                try {
+                    return getBuiltinModule('worker_threads').MessageChannel;
+                }
+                catch (_) { }
+                return undefined;
+            })(),
+        setImmediate: typeof setImmediate === 'function'
+            ? setImmediate.bind(getGlobalThis())
+            : function (callback) {
+                if (typeof callback !== 'function') {
+                    throw new TypeError('The "callback" argument must be of type function');
+                }
+                if (ret.MessageChannel) {
+                    let channel = new ret.MessageChannel();
+                    channel.port1.onmessage = function () {
+                        channel.port1.onmessage = null;
+                        channel = undefined;
+                        callback();
+                    };
+                    channel.port2.postMessage(null);
+                }
+                else {
+                    setTimeout(callback, 0);
+                }
+            },
+        Buffer: typeof Buffer === 'function'
+            ? Buffer
+            : (function () {
+                try {
+                    return getBuiltinModule('buffer').Buffer;
+                }
+                catch (_) { }
+                return undefined;
+            })(),
+        ...features,
+        getGlobalThis,
+        withResolvers
+    };
+    return ret;
+}
+function isReferenceType(v) {
+    return (typeof v === 'object' && v !== null) || typeof v === 'function';
+}
+function getDylinkMetadata(binary) {
+    let offset = 0;
+    let end = 0;
+    const decoder = new TextDecoder();
+    function getU8() {
+        return binary[offset++];
+    }
+    function getLEB() {
+        let ret = 0;
+        let mul = 1;
+        while (1) {
+            let byte = binary[offset++];
+            ret += ((byte & 0x7f) * mul);
+            mul *= 0x80;
+            if (!(byte & 0x80))
+                break;
+        }
+        return ret;
+    }
+    function getString() {
+        let len = getLEB();
+        offset += len;
+        return decoder.decode(binary.subarray(offset - len, offset));
+    }
+    function getStringList() {
+        let count = getLEB();
+        let rtn = [];
+        while (count--)
+            rtn.push(getString());
+        return rtn;
+    }
+    function failIf(condition, message) {
+        if (condition)
+            throw new Error(message);
+    }
+    if (binary instanceof WebAssembly.Module) {
+        const dylinkSection = WebAssembly.Module.customSections(binary, 'dylink.0');
+        failIf(dylinkSection.length === 0, 'need dylink section');
+        binary = new Uint8Array(dylinkSection[0]);
+        end = binary.length;
+    }
+    else {
+        var int32View = new Uint32Array(new Uint8Array(binary.subarray(0, 24)).buffer);
+        var magicNumberFound = int32View[0] === 0x6d736100 || int32View[0] === 0x0061736d;
+        failIf(!magicNumberFound, 'need to see wasm magic number');
+        failIf(binary[8] !== 0, 'need the dylink section to be first');
+        offset = 9;
+        var section_size = getLEB();
+        end = offset + section_size;
+        var name = getString();
+        failIf(name !== 'dylink.0');
+    }
+    var customSection = {
+        neededDynlibs: [],
+        tlsExports: new Set(),
+        weakImports: new Set(),
+        runtimePaths: [],
+        memorySize: 0,
+        memoryAlign: 0,
+        tableSize: 0,
+        tableAlign: 0
+    };
+    var WASM_DYLINK_MEM_INFO = 0x1;
+    var WASM_DYLINK_NEEDED = 0x2;
+    var WASM_DYLINK_EXPORT_INFO = 0x3;
+    var WASM_DYLINK_IMPORT_INFO = 0x4;
+    var WASM_DYLINK_RUNTIME_PATH = 0x5;
+    var WASM_SYMBOL_TLS = 0x100;
+    var WASM_SYMBOL_BINDING_MASK = 0x3;
+    var WASM_SYMBOL_BINDING_WEAK = 0x1;
+    while (offset < end) {
+        var subsectionType = getU8();
+        var subsectionSize = getLEB();
+        if (subsectionType === WASM_DYLINK_MEM_INFO) {
+            customSection.memorySize = getLEB();
+            customSection.memoryAlign = getLEB();
+            customSection.tableSize = getLEB();
+            customSection.tableAlign = getLEB();
+        }
+        else if (subsectionType === WASM_DYLINK_NEEDED) {
+            customSection.neededDynlibs = getStringList();
+        }
+        else if (subsectionType === WASM_DYLINK_EXPORT_INFO) {
+            let count = getLEB();
+            while (count--) {
+                let symname = getString();
+                let flags = getLEB();
+                if (flags & WASM_SYMBOL_TLS) {
+                    customSection.tlsExports.add(symname);
+                }
+            }
+        }
+        else if (subsectionType === WASM_DYLINK_IMPORT_INFO) {
+            let count = getLEB();
+            while (count--) {
+                getString();
+                let symname = getString();
+                let flags = getLEB();
+                if ((flags & WASM_SYMBOL_BINDING_MASK) === WASM_SYMBOL_BINDING_WEAK) {
+                    customSection.weakImports.add(symname);
+                }
+            }
+        }
+        else if (subsectionType === WASM_DYLINK_RUNTIME_PATH) {
+            customSection.runtimePaths = getStringList();
+        }
+        else {
+            console.error('unknown dylink.0 subsection:', subsectionType);
+            offset += subsectionSize;
+        }
+    }
+    var tableAlign = Math.pow(2, customSection.tableAlign);
+    failIf(tableAlign !== 1, `invalid tableAlign ${tableAlign}`);
+    failIf(offset !== end);
+    return customSection;
+}
+const version = "2.0.0-alpha.5";
+const NODE_API_SUPPORTED_VERSION_MIN = 1;
+const NODE_API_SUPPORTED_VERSION_MAX = 10;
+const NAPI_VERSION_EXPERIMENTAL = 2147483647;
+const NODE_API_DEFAULT_MODULE_API_VERSION = 8;
+const NODE_MODULE_VERSION = 127;
+
+//#endregion src/util.ts
+
+//#region src/Disaposable.ts
+class Disposable {
+}
+if (typeof Symbol.dispose === 'symbol') {
+    Object.defineProperty(Disposable.prototype, Symbol.dispose, {
+        value() {
+            this.dispose();
+        },
+        writable: true,
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//#endregion src/Disaposable.ts
+
+//#region src/RefTracker.ts
+class RefTracker extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._next = null;
+        this._prev = null;
+    }
+    dispose() { }
+    finalize() { }
+    link(list) {
+        this._prev = list;
+        this._next = list._next;
+        if (this._next !== null) {
+            this._next._prev = this;
+        }
+        list._next = this;
+    }
+    unlink() {
+        if (this._prev !== null) {
+            this._prev._next = this._next;
+        }
+        if (this._next !== null) {
+            this._next._prev = this._prev;
+        }
+        this._prev = null;
+        this._next = null;
+    }
+    static finalizeAll(list) {
+        while (list._next !== null) {
+            list._next.finalize();
+        }
+    }
+}
+
+//#endregion src/RefTracker.ts
+
+//#region src/Finalizer.ts
+class Finalizer {
+    constructor(envObject, _finalizeCallback = 0, _finalizeData = 0, _finalizeHint = 0) {
+        this.envObject = envObject;
+        this._finalizeCallback = _finalizeCallback;
+        this._finalizeData = _finalizeData;
+        this._finalizeHint = _finalizeHint;
+        this._makeDynCall_vppp = envObject.bridge.makeDynCall_vppp;
+    }
+    copy() {
+        const newFina = Object.create(Finalizer.prototype);
+        newFina.envObject = this.envObject;
+        newFina._makeDynCall_vppp = this._makeDynCall_vppp;
+        newFina._finalizeCallback = this._finalizeCallback;
+        newFina._finalizeData = this._finalizeData;
+        newFina._finalizeHint = this._finalizeHint;
+        return newFina;
+    }
+    move(target) {
+        target._finalizeCallback = this._finalizeCallback;
+        target._finalizeData = this._finalizeData;
+        target._finalizeHint = this._finalizeHint;
+        target.envObject = this.envObject;
+        target._makeDynCall_vppp = this._makeDynCall_vppp;
+        this._finalizeCallback = 0;
+        this._finalizeData = 0;
+        this._finalizeHint = 0;
+        this.dispose();
+    }
+    callback() { return this._finalizeCallback; }
+    data() { return this._finalizeData; }
+    hint() { return this._finalizeHint; }
+    resetEnv() {
+        this.envObject = undefined;
+    }
+    resetFinalizer() {
+        this._finalizeCallback = 0;
+        this._finalizeData = 0;
+        this._finalizeHint = 0;
+    }
+    callFinalizer() {
+        const finalize_callback = this._finalizeCallback;
+        const finalize_data = this._finalizeData;
+        const finalize_hint = this._finalizeHint;
+        this.resetFinalizer();
+        if (!finalize_callback)
+            return;
+        const 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);
+        }
+    }
+    dispose() {
+        this.envObject = undefined;
+        this._makeDynCall_vppp = undefined;
+    }
+}
+
+//#endregion src/Finalizer.ts
+
+//#region src/TrackedFinalizer.ts
+class TrackedFinalizer extends RefTracker {
+    static create(envObject, finalize_callback, finalize_data, finalize_hint) {
+        const finalizer = new TrackedFinalizer(envObject, finalize_callback, finalize_data, finalize_hint);
+        finalizer.link(envObject.finalizing_reflist);
+        return finalizer;
+    }
+    constructor(envObject, finalize_callback, finalize_data, finalize_hint) {
+        super();
+        this._finalizer = new Finalizer(envObject, finalize_callback, finalize_data, finalize_hint);
+    }
+    data() {
+        return this._finalizer.data();
+    }
+    dispose() {
+        if (!this._finalizer)
+            return;
+        this.unlink();
+        this._finalizer.envObject.dequeueFinalizer(this);
+        this._finalizer.dispose();
+        this._finalizer = undefined;
+        super.dispose();
+    }
+    finalize() {
+        this.unlink();
+        let error;
+        let caught = false;
+        try {
+            this._finalizer.callFinalizer();
+        }
+        catch (err) {
+            caught = true;
+            error = err;
+        }
+        this.dispose();
+        if (caught) {
+            throw error;
+        }
+    }
+}
+
+//#endregion src/TrackedFinalizer.ts
+
+//#region src/Store.ts
+class CountIdAllocator extends Disposable {
+    constructor(initialNext = 1) {
+        super();
+        this.next = initialNext;
+    }
+    aquire() {
+        return this.next++;
+    }
+    release(_) { }
+    dispose() { }
+}
+class CountIdReuseAllocator extends CountIdAllocator {
+    constructor() {
+        super(...arguments);
+        this._freeList = [];
+        this._freeListHead = 0;
+    }
+    aquire() {
+        if (this._freeListHead < this._freeList.length) {
+            const id = this._freeList[this._freeListHead++];
+            if (this._freeListHead === this._freeList.length) {
+                this._freeList.length = 0;
+                this._freeListHead = 0;
+            }
+            return id;
+        }
+        return super.aquire();
+    }
+    release(id) {
+        this._freeList.push(id);
+    }
+    dispose() {
+        this._freeList.length = 0;
+        this._freeListHead = 0;
+        super.dispose();
+    }
+}
+class BaseArrayStore extends Disposable {
+    constructor(initialCapacity = 1) {
+        super();
+        this._values = [undefined];
+        for (let i = 1; i < initialCapacity; i++) {
+            this._values.push(undefined);
+        }
+    }
+    assign(id, value) {
+        this._values[id] = value;
+        return value;
+    }
+    deref(id) {
+        return this._values[id];
+    }
+    alloc(factory, ...args) {
+        return factory(...args);
+    }
+    dealloc(id) {
+        this._values[id] = undefined;
+    }
+    dispose() {
+        this._values.forEach((_, i) => this.dealloc(i));
+    }
+}
+class ArrayStore extends BaseArrayStore {
+    constructor(initialCapacity = 4) {
+        super(initialCapacity);
+        this._allocator = new CountIdReuseAllocator(1);
+    }
+    insert(value) {
+        const id = this._allocator.aquire();
+        value.id = id;
+        this._values[id] = value;
+    }
+    alloc(factory, ...args) {
+        const value = factory(...args);
+        this.insert(value);
+        return value;
+    }
+    dealloc(id) {
+        this._allocator.release(id);
+        super.dealloc(id);
+    }
+}
+
+//#endregion src/Store.ts
+
+//#region src/Persistent.ts
+class PersistentStore extends ArrayStore {
+    constructor(initialCapacity = 4) {
+        super(initialCapacity);
+        this._recyleList = [];
+        this._recyleListHead = 0;
+    }
+    markUnused(id) {
+        this._recyleList.push(id);
+    }
+    recycle() {
+        while (this._recyleListHead < this._recyleList.length) {
+            const id = this._recyleList[this._recyleListHead++];
+            if (this._recyleListHead === this._recyleList.length) {
+                this._recyleList.length = 0;
+                this._recyleListHead = 0;
+            }
+            const persistent = this.deref(id);
+            persistent.dispose();
+        }
+    }
+}
+class StrongRef extends Disposable {
+    constructor(value) {
+        super();
+        this._value = value;
+    }
+    deref() {
+        return this._value;
+    }
+    dispose() {
+        this._value = undefined;
+    }
+}
+class Persistent extends Disposable {
+    constructor(isolate, ...args) {
+        super();
+        this.id = 0;
+        this._isolate = isolate;
+        isolate.insertRef(this);
+        this._slotId = 0x80000000 + this.id;
+        this.setSlot(args.length === 0 ? undefined : new StrongRef(args[0]));
+    }
+    dispose() {
+        this.reset();
+        this.deleteSlot();
+        this._isolate.globalHandleStore.dealloc(this.id);
+        this._isolate = undefined;
+        this.id = 0;
+    }
+    copy() {
+        const target = new Persistent(this._isolate);
+        target._param = this._param;
+        target._callback = this._callback;
+        const ref = this.getSlot();
+        if (ref instanceof StrongRef) {
+            target.setSlot(new StrongRef(ref.deref()));
+        }
+        else if (ref instanceof WeakRef) {
+            const value = ref.deref();
+            if (value === undefined) {
+                target.setSlot(undefined);
+            }
+            else {
+                target.setSlot(new StrongRef(value));
+                target.setWeak(this._param, this._callback);
+            }
+        }
+        else {
+            target.setSlot(undefined);
+        }
+        return target;
+    }
+    move(to) {
+        if (this === to)
+            return;
+        to.reset();
+        to._param = this._param;
+        to._callback = this._callback;
+        to._isolate = this._isolate;
+        to.setSlot(this.getSlot());
+        this.reset();
+        this.setSlot(undefined);
+    }
+    slot() {
+        return this._slotId;
+    }
+    getSlot() {
+        return this._isolate.getRefSlotValue(this.slot());
+    }
+    setSlot(ref) {
+        this._isolate.setRefSlotValue(this.slot(), ref);
+    }
+    deleteSlot() {
+        this._isolate.deleteRefSlotValue(this.slot());
+    }
+    setWeak(param, callback) {
+        const ref = this.getSlot();
+        if (!supportFinalizer || ref === undefined || ref instanceof WeakRef)
+            return;
+        const value = ref.deref();
+        try {
+            Persistent._registry.register(value, this, this);
+            const weakRef = new WeakRef(value);
+            ref.dispose();
+            this.setSlot(weakRef);
+            this._param = param;
+            this._callback = callback;
+        }
+        catch (err) {
+            if (typeof value === 'symbol') ;
+            else {
+                throw err;
+            }
+        }
+    }
+    clearWeak() {
+        const ref = this.getSlot();
+        if (!supportFinalizer || ref === undefined)
+            return;
+        if (ref instanceof WeakRef) {
+            try {
+                Persistent._registry.unregister(this);
+            }
+            catch (_) { }
+            this._param = undefined;
+            this._callback = undefined;
+            const value = ref.deref();
+            if (value === undefined) {
+                this.setSlot(value);
+            }
+            else {
+                this.setSlot(new StrongRef(value));
+            }
+        }
+    }
+    reset() {
+        if (supportFinalizer) {
+            try {
+                Persistent._registry.unregister(this);
+            }
+            catch (_) { }
+        }
+        this._param = undefined;
+        this._callback = undefined;
+        const ref = this.getSlot();
+        if (ref instanceof StrongRef) {
+            ref.dispose();
+        }
+        this.setSlot(undefined);
+    }
+    resetTo(value) {
+        this.reset();
+        this.setSlot(new StrongRef(value));
+    }
+    isEmpty() {
+        return this.getSlot() === undefined;
+    }
+    deref() {
+        const ref = this.getSlot();
+        if (ref === undefined)
+            return undefined;
+        return ref.deref();
+    }
+}
+Persistent._registry = supportFinalizer
+    ? new FinalizationRegistry((value) => {
+        value.setSlot(undefined);
+        const callback = value._callback;
+        const param = value._param;
+        value._callback = undefined;
+        value._param = undefined;
+        if (typeof callback === 'function') {
+            callback(param);
+        }
+    })
+    : undefined;
+
+//#endregion src/Persistent.ts
+
+//#region src/env.ts
+function handleThrow(envObject, value) {
+    if (envObject.terminatedOrTerminating()) {
+        return;
+    }
+    throw value;
+}
+class Env extends Disposable {
+    constructor(ctx, store, bridge) {
+        super();
+        this.openHandleScopes = 0;
+        this.instanceData = null;
+        this.refs = 1;
+        this.reflist = new RefTracker();
+        this.finalizing_reflist = new RefTracker();
+        this.pendingFinalizers = new Set();
+        this.inGcFinalizer = false;
+        this._bindingMap = new WeakMap();
+        this.ctx = ctx;
+        this.store = store;
+        this.id = 0;
+        this.store.insert(this);
+        this.lastException = new Persistent(ctx.isolate);
+        this.bridge = bridge;
+    }
+    canCallIntoJs() {
+        return true;
+    }
+    terminatedOrTerminating() {
+        return !this.canCallIntoJs();
+    }
+    ref() {
+        this.refs++;
+    }
+    unref() {
+        this.refs--;
+        if (this.refs === 0) {
+            this.dispose();
+        }
+    }
+    clearLastError() {
+        this.bridge.setLastError(this.bridge.address, 0, 0, 0);
+        return 0;
+    }
+    setLastError(error_code, engine_error_code = 0, engine_reserved = 0) {
+        this.bridge.setLastError(this.bridge.address, error_code, engine_error_code, engine_reserved);
+        return error_code;
+    }
+    callIntoModule(fn, handleException = handleThrow) {
+        const openHandleScopesBefore = this.openHandleScopes;
+        this.clearLastError();
+        const r = fn(this);
+        if (openHandleScopesBefore !== this.openHandleScopes) {
+            this.bridge.abort('open_handle_scopes != open_handle_scopes_before');
+        }
+        if (!this.lastException.isEmpty()) {
+            const err = this.lastException.deref();
+            this.lastException.reset();
+            handleException(this, err);
+        }
+        return r;
+    }
+    invokeFinalizerFromGC(finalizer) {
+        if (this.moduleApiVersion !== NAPI_VERSION_EXPERIMENTAL) {
+            this.enqueueFinalizer(finalizer);
+        }
+        else {
+            const saved = this.inGcFinalizer;
+            this.inGcFinalizer = true;
+            try {
+                finalizer.finalize();
+            }
+            finally {
+                this.inGcFinalizer = saved;
+            }
+        }
+    }
+    checkGCAccess() {
+        if (this.moduleApiVersion === NAPI_VERSION_EXPERIMENTAL && this.inGcFinalizer) {
+            this.bridge.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.');
+        }
+    }
+    enqueueFinalizer(finalizer) {
+        this.pendingFinalizers.add(finalizer);
+    }
+    dequeueFinalizer(finalizer) {
+        this.pendingFinalizers.delete(finalizer);
+    }
+    deleteMe() {
+        RefTracker.finalizeAll(this.finalizing_reflist);
+        RefTracker.finalizeAll(this.reflist);
+        this.lastException.reset();
+        this.store.dealloc(this.id);
+        this.bridge.deleteEnv(this.bridge.address);
+    }
+    dispose() {
+        if (this.id === 0)
+            return;
+        this.deleteMe();
+        this.finalizing_reflist.dispose();
+        this.reflist.dispose();
+        this.id = 0;
+    }
+    initObjectBinding(value) {
+        const binding = {
+            wrapped: 0,
+            tag: null
+        };
+        this._bindingMap.set(value, binding);
+        return binding;
+    }
+    getObjectBinding(value) {
+        if (this._bindingMap.has(value)) {
+            return this._bindingMap.get(value);
+        }
+        return this.initObjectBinding(value);
+    }
+    setInstanceData(data, finalize_cb, finalize_hint) {
+        if (this.instanceData) {
+            this.instanceData.dispose();
+        }
+        this.instanceData = TrackedFinalizer.create(this, finalize_cb, data, finalize_hint);
+    }
+    getInstanceData() {
+        return this.instanceData ? this.instanceData.data() : 0;
+    }
+}
+class NodeEnv extends Env {
+    constructor(ctx, store, bridge) {
+        super(ctx, store, bridge);
+        this.destructing = false;
+        this.finalizationScheduled = false;
+        this.bridge = bridge;
+    }
+    deleteMe() {
+        this.destructing = true;
+        this.drainFinalizerQueue();
+        super.deleteMe();
+    }
+    canCallIntoJs() {
+        return super.canCallIntoJs() && this.ctx.canCallIntoJs();
+    }
+    triggerFatalException(err) {
+        if (this.nodeBinding) {
+            this.nodeBinding.napi.fatalException(err);
+        }
+        else {
+            if (typeof process === 'object' && process !== null && typeof process._fatalException === 'function') {
+                const handled = process._fatalException(err);
+                if (!handled) {
+                    console.error(err);
+                    process.exit(1);
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    callbackIntoModule(enforceUncaughtExceptionPolicy, fn) {
+        return this.callIntoModule(fn, (envObject, err) => {
+            if (envObject.terminatedOrTerminating()) {
+                return;
+            }
+            const hasProcess = typeof process === 'object' && process !== null;
+            const hasForceFlag = hasProcess ? Boolean(process.execArgv && (process.execArgv.indexOf('--force-node-api-uncaught-exceptions-policy') !== -1)) : false;
+            if (envObject.moduleApiVersion < 10 && !hasForceFlag && !enforceUncaughtExceptionPolicy) {
+                const warn = hasProcess && typeof process.emitWarning === 'function'
+                    ? process.emitWarning
+                    : function (warning, type, code) {
+                        if (warning instanceof Error) {
+                            console.warn(warning.toString());
+                        }
+                        else {
+                            const prefix = code ? `[${code}] ` : '';
+                            console.warn(`${prefix}${type || 'Warning'}: ${warning}`);
+                        }
+                    };
+                warn('Uncaught Node-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);
+        });
+    }
+    callFinalizer(cb, data, hint) {
+        this.callFinalizerInternal(1, cb, data, hint);
+    }
+    callFinalizerInternal(forceUncaught, cb, data, hint) {
+        const f = this.bridge.makeDynCall_vppp(cb);
+        const env = this.bridge.address;
+        const scope = this.ctx.openScope(this);
+        try {
+            this.callbackIntoModule(Boolean(forceUncaught), () => { f(env, data, hint); });
+        }
+        finally {
+            this.ctx.closeScope(this, scope);
+        }
+    }
+    enqueueFinalizer(finalizer) {
+        super.enqueueFinalizer(finalizer);
+        if (!this.finalizationScheduled && !this.destructing) {
+            this.finalizationScheduled = true;
+            this.ref();
+            this.ctx.features.setImmediate(() => {
+                this.finalizationScheduled = false;
+                this.unref();
+                this.drainFinalizerQueue();
+            });
+        }
+    }
+    drainFinalizerQueue() {
+        for (const refTracker of this.pendingFinalizers) {
+            this.pendingFinalizers.delete(refTracker);
+            refTracker.finalize();
+        }
+    }
+}
+
+//#endregion src/env.ts
+
+//#region src/errors.ts
+class EmnapiError extends Error {
+    constructor(message) {
+        super(message);
+        const ErrorConstructor = new.target;
+        const proto = ErrorConstructor.prototype;
+        if (!(this instanceof EmnapiError)) {
+            const setPrototypeOf = Object.setPrototypeOf;
+            if (typeof setPrototypeOf === 'function') {
+                setPrototypeOf.call(Object, this, proto);
+            }
+            else {
+                this.__proto__ = proto;
+            }
+            if (typeof Error.captureStackTrace === 'function') {
+                Error.captureStackTrace(this, ErrorConstructor);
+            }
+        }
+    }
+}
+Object.defineProperty(EmnapiError.prototype, 'name', {
+    configurable: true,
+    writable: true,
+    value: 'EmnapiError'
+});
+class NotSupportWeakRefError extends EmnapiError {
+    constructor(api, message) {
+        super(`${api}: The current runtime does not support "FinalizationRegistry" and "WeakRef".${message ? ` ${message}` : ''}`);
+    }
+}
+Object.defineProperty(NotSupportWeakRefError.prototype, 'name', {
+    configurable: true,
+    writable: true,
+    value: 'NotSupportWeakRefError'
+});
+class NotSupportBufferError extends EmnapiError {
+    constructor(api, message) {
+        super(`${api}: The current runtime does not support "Buffer". Consider using buffer polyfill to make sure \`globalThis.Buffer\` is defined.${message ? ` ${message}` : ''}`);
+    }
+}
+Object.defineProperty(NotSupportBufferError.prototype, 'name', {
+    configurable: true,
+    writable: true,
+    value: 'NotSupportBufferError'
+});
+
+//#endregion src/errors.ts
+
+//#region src/Reference.ts
+var ReferenceOwnership;
+(function (ReferenceOwnership) {
+    ReferenceOwnership[ReferenceOwnership["kRuntime"] = 0] = "kRuntime";
+    ReferenceOwnership[ReferenceOwnership["kUserland"] = 1] = "kUserland";
+})(ReferenceOwnership || (ReferenceOwnership = {}));
+function canBeHeldWeakly(value) {
+    if (!value)
+        return false;
+    const type = typeof value;
+    return type === 'object' || type === 'function' || type === 'symbol';
+}
+class Reference extends RefTracker {
+    static weakCallback(ref) {
+        const persistent = ref.getPersistent();
+        persistent.reset();
+        ref.invokeFinalizerFromGC();
+    }
+    static create(ctx, envObject, handle_id, initialRefcount, ownership, _unused1, _unused2, _unused3) {
+        const ref = new Reference(ctx, envObject, handle_id, initialRefcount, ownership);
+        if (envObject) {
+            ref.link(envObject.reflist);
+        }
+        return ref;
+    }
+    constructor(ctx, envObject, handle_id, initialRefcount, ownership) {
+        super();
+        this.envObject = envObject;
+        this._refcount = initialRefcount;
+        this._ownership = ownership;
+        const value = envObject ? envObject.ctx.jsValueFromNapiValue(handle_id) : handle_id;
+        this.canBeWeak = canBeHeldWeakly(value);
+        this.ctx = ctx;
+        this.id = new Persistent(ctx.isolate, value).id;
+        ctx.refStore.set(this.id, this);
+        if (initialRefcount === 0) {
+            this._setWeak();
+        }
+    }
+    getPersistent() {
+        return this.ctx.isolate.getRef(this.id);
+    }
+    ref() {
+        const persistent = this.getPersistent();
+        if (persistent.isEmpty()) {
+            return 0;
+        }
+        if (++this._refcount === 1 && this.canBeWeak) {
+            persistent.clearWeak();
+        }
+        return this._refcount;
+    }
+    unref() {
+        const persistent = this.getPersistent();
+        if (persistent.isEmpty() || this._refcount === 0) {
+            return 0;
+        }
+        if (--this._refcount === 0) {
+            this._setWeak();
+        }
+        return this._refcount;
+    }
+    deref() {
+        const persistent = this.getPersistent();
+        return persistent.deref();
+    }
+    get() {
+        const persistent = this.getPersistent();
+        if (persistent.isEmpty()) {
+            return 0;
+        }
+        return persistent.slot();
+    }
+    resetFinalizer() { }
+    data() { return 0; }
+    refcount() { return this._refcount; }
+    ownership() { return this._ownership; }
+    callUserFinalizer() { }
+    invokeFinalizerFromGC() {
+        this.finalize();
+    }
+    _setWeak() {
+        this.setWeakWithData(this, Reference.weakCallback);
+    }
+    setWeakWithData(data, callback) {
+        const persistent = this.getPersistent();
+        if (this.canBeWeak) {
+            persistent.setWeak(data, callback);
+        }
+        else {
+            persistent.reset();
+        }
+    }
+    clearWeak() {
+        const persistent = this.getPersistent();
+        persistent.clearWeak();
+    }
+    finalize() {
+        const persistent = this.getPersistent();
+        persistent.reset();
+        const deleteMe = this._ownership === ReferenceOwnership.kRuntime;
+        this.unlink();
+        this.callUserFinalizer();
+        if (deleteMe) {
+            this.dispose();
+        }
+    }
+    dispose() {
+        if (this.id === 0)
+            return;
+        this.unlink();
+        this.ctx.isolate.removeRef(this.id);
+        this.ctx.refStore.delete(this.id);
+        super.dispose();
+        this.ctx = undefined;
+        this.envObject = undefined;
+        this.id = 0;
+    }
+}
+class ReferenceWithData extends Reference {
+    static create(ctx, envObject, value, initialRefcount, ownership, data) {
+        const reference = new ReferenceWithData(ctx, envObject, value, initialRefcount, ownership, data);
+        if (envObject) {
+            reference.link(envObject.reflist);
+        }
+        return reference;
+    }
+    constructor(ctx, envObject, value, initialRefcount, ownership, data) {
+        super(ctx, envObject, value, initialRefcount, ownership);
+        this._data = data;
+    }
+    data() {
+        return this._data;
+    }
+}
+class ReferenceWithFinalizer extends Reference {
+    static create(ctx, envObject, value, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) {
+        if (!envObject) {
+            throw new TypeError('envObject is required for ReferenceWithFinalizer');
+        }
+        const reference = new ReferenceWithFinalizer(ctx, envObject, value, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint);
+        reference.link(envObject.finalizing_reflist);
+        return reference;
+    }
+    constructor(ctx, envObject, value, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) {
+        super(ctx, envObject, value, initialRefcount, ownership);
+        this._finalizer = new Finalizer(envObject, finalize_callback, finalize_data, finalize_hint);
+    }
+    resetFinalizer() {
+        this._finalizer.resetFinalizer();
+    }
+    data() {
+        return this._finalizer.data();
+    }
+    callUserFinalizer() {
+        this._finalizer.callFinalizer();
+    }
+    invokeFinalizerFromGC() {
+        this._finalizer.envObject.invokeFinalizerFromGC(this);
+    }
+    dispose() {
+        if (!this._finalizer)
+            return;
+        this._finalizer.envObject.dequeueFinalizer(this);
+        this._finalizer.dispose();
+        super.dispose();
+        this._finalizer = undefined;
+    }
+}
+
+//#endregion src/Reference.ts
+
+//#region src/Handle.ts
+class HandleStore extends BaseArrayStore {
+    constructor(features) {
+        super(HandleStore.MIN_ID);
+        this._features = features;
+        this._allocator = new CountIdAllocator(HandleStore.MIN_ID);
+        this.refValues = new Map();
+        this._values[2] = undefined;
+        this._values[3] = null;
+        this._values[4] = false;
+        this._values[5] = true;
+        this._values[6] = features.getGlobalThis();
+        this._values[7] = '';
+        const _erase = (start, end) => {
+            for (let i = start; i < end; ++i) {
+                this.dealloc(i);
+            }
+        };
+        this._erase = this._features.finalizer
+            ? this._features.weakSymbol
+                ? (start, end, weak) => {
+                    if (!weak) {
+                        _erase(start, end);
+                    }
+                    else {
+                        for (let i = start; i < end; ++i) {
+                            const value = this._values[i];
+                            const type = typeof value;
+                            if ((type === 'object' && value !== null) || (type === 'function') || (type === 'symbol' && Symbol.keyFor(value) === undefined)) {
+                                this._values[i] = new WeakRef(value);
+                            }
+                        }
+                    }
+                }
+                : (start, end, weak) => {
+                    if (!weak) {
+                        _erase(start, end);
+                    }
+                    else {
+                        for (let i = start; i < end; ++i) {
+                            const value = this._values[i];
+                            const type = typeof value;
+                            if ((type === 'object' && value !== null) || (type === 'function')) {
+                                this._values[i] = new WeakRef(value);
+                            }
+                        }
+                    }
+                }
+            : _erase;
+        this._deref = this._features.finalizer
+            ? (id) => {
+                id = Number(id);
+                if (id < 0 || id > 0x7fffffff) {
+                    const ref = this.refValues.get(id >>> 0);
+                    if (ref === undefined)
+                        return undefined;
+                    return ref.deref();
+                }
+                const value = this._values[id];
+                if (value instanceof WeakRef && this.isOutOfScope(id)) {
+                    return value.deref();
+                }
+                return value;
+            }
+            : (id) => {
+                id = Number(id);
+                if (id < 0 || id > 0x7fffffff) {
+                    const ref = this.refValues.get(id >>> 0);
+                    if (ref === undefined)
+                        return undefined;
+                    return ref.deref();
+                }
+                const value = this._values[id];
+                return value;
+            };
+    }
+    isOutOfScope(id) {
+        return id >= this._allocator.next;
+    }
+    deepDeref(id) {
+        return this._deref(id);
+    }
+    push(value) {
+        const next = this._allocator.aquire();
+        this._values[next] = value;
+        return next;
+    }
+    erase(start, end, weak) {
+        this._allocator.next = start;
+        this._erase(start, end, weak);
+    }
+    swap(a, b) {
+        const values = this._values;
+        const h = values[a];
+        values[a] = values[b];
+        values[b] = h;
+    }
+}
+HandleStore.MIN_ID = 8;
+
+//#endregion src/Handle.ts
+
+//#region src/External.ts
+const externalValue = new WeakMap();
+function isExternal(object) {
+    return externalValue.has(object);
+}
+const External = (() => {
+    function External(value) {
+        Object.setPrototypeOf(this, null);
+        externalValue.set(this, value);
+    }
+    External.prototype = null;
+    return External;
+})();
+function getExternalValue(external) {
+    if (!isExternal(external)) {
+        throw new TypeError('not external');
+    }
+    return externalValue.get(external);
+}
+
+//#endregion src/External.ts
+
+//#region src/HandleScope.ts
+class HandleScope extends Disposable {
+    static create(parentScope, handleStore, start = parentScope?.end ?? 1, end = start) {
+        return new HandleScope(parentScope, handleStore, start, end);
+    }
+    constructor(parentScope, handleStore, start = parentScope?.end ?? 1, end = start) {
+        super();
+        this._escapeCalled = false;
+        this.handleStore = handleStore;
+        this.id = 0;
+        this.parent = parentScope;
+        this.child = null;
+        if (parentScope !== null)
+            parentScope.child = this;
+        this.start = start;
+        this.end = end;
+        this.callbackInfo = {
+            thiz: undefined,
+            holder: undefined,
+            data: 0,
+            args: undefined,
+            fn: undefined
+        };
+    }
+    reuse(parentScope) {
+        this.start = this.end = parentScope.end;
+        this._escapeCalled = false;
+    }
+    add(value) {
+        const h = this.handleStore.push(value);
+        this.end = h + 1;
+        return h;
+    }
+    addExternal(data) {
+        return this.add(new External(data));
+    }
+    dispose() {
+        const weak = this.callbackInfo.fn === undefined;
+        if (!weak) {
+            this.callbackInfo.data = 0;
+            this.callbackInfo.args = undefined;
+            this.callbackInfo.thiz = undefined;
+            this.callbackInfo.holder = undefined;
+            this.callbackInfo.fn = undefined;
+        }
+        if (this.start === this.end)
+            return;
+        this.handleStore.erase(this.start, this.end, weak);
+    }
+    escape(handle) {
+        if (handle < this.start || handle >= this.end)
+            return handle;
+        if (this._escapeCalled)
+            return 0;
+        this._escapeCalled = true;
+        const id = this.start;
+        this.handleStore.swap(handle, id);
+        this.start++;
+        this.parent.end++;
+        return id;
+    }
+    escapeCalled() {
+        return this._escapeCalled;
+    }
+}
+
+//#endregion src/HandleScope.ts
+
+//#region src/ScopeStore.ts
+class ScopeStore extends BaseArrayStore {
+    constructor() {
+        super();
+        this._rootScope = new HandleScope(null, null, 1, HandleStore.MIN_ID);
+        this.currentScope = this._rootScope;
+    }
+    openScope(handleStore) {
+        const currentScope = this.currentScope;
+        let scope = currentScope.child;
+        if (scope) {
+            scope.reuse(currentScope);
+        }
+        else {
+            scope = new HandleScope(currentScope, handleStore);
+            const id = currentScope.id + 1;
+            scope.id = id;
+            this._values[id] = scope;
+        }
+        this.currentScope = scope;
+        return scope;
+    }
+    closeScope() {
+        const scope = this.currentScope;
+        this.currentScope = scope.parent;
+        scope.dispose();
+    }
+    isEmpty() {
+        return this.currentScope === this._rootScope;
+    }
+}
+
+//#endregion src/ScopeStore.ts
+
+//#region src/TryCatch.ts
+class TryCatch {
+    constructor(id) {
+        this.id = 0;
+        this._exception = undefined;
+        this._caught = false;
+        this._next = null;
+        this.id = id;
+        this._next = TryCatch.top;
+        TryCatch.top = this;
+        TryCatch._map.set(id, this);
+    }
+    static deref(id) {
+        return this._map.get(id);
+    }
+    static pop() {
+        const top = TryCatch.top;
+        if (top) {
+            TryCatch._map.delete(top.id);
+            TryCatch.top = top._next;
+            top._next = null;
+            top.id = 0;
+            top._exception = undefined;
+            top._caught = false;
+        }
+    }
+    isEmpty() {
+        return !this._caught;
+    }
+    hasCaught() {
+        return this._caught;
+    }
+    exception() {
+        return this._exception;
+    }
+    rethrow(ctx) {
+        if (this._caught) {
+            const e = this.extractException();
+            ctx.setLastException(e);
+            return e;
+        }
+        return undefined;
+    }
+    setError(err) {
+        this._caught = true;
+        this._exception = err;
+    }
+    reset() {
+        this._caught = false;
+        this._exception = undefined;
+    }
+    extractException() {
+        const e = this._exception;
+        this.reset();
+        return e;
+    }
+}
+TryCatch.top = null;
+TryCatch._map = new Map();
+
+//#endregion src/TryCatch.ts
+
+//#region src/Template.ts
+var PropertyAttribute;
+(function (PropertyAttribute) {
+    PropertyAttribute[PropertyAttribute["None"] = 0] = "None";
+    PropertyAttribute[PropertyAttribute["ReadOnly"] = 1] = "ReadOnly";
+    PropertyAttribute[PropertyAttribute["DontEnum"] = 2] = "DontEnum";
+    PropertyAttribute[PropertyAttribute["DontDelete"] = 4] = "DontDelete";
+})(PropertyAttribute || (PropertyAttribute = {}));
+class Template {
+    constructor(ctx) {
+        this._properties = new Map();
+        this.ctx = ctx;
+    }
+    set(name, value, attr) {
+        this._properties.set(name, [value, attr]);
+    }
+    _addPropertiesToInstance(instance) {
+        this._properties.forEach((property, name) => {
+            const [v, attr] = property;
+            if (v instanceof Template) {
+                if ('newInstance' in v) {
+                    Object.defineProperty(instance, name, {
+                        value: v.newInstance(6),
+                        writable: !(attr & 1),
+                        enumerable: !(attr & 2),
+                        configurable: !(attr & 4)
+                    });
+                }
+                else if ('getFunction' in v) {
+                    Object.defineProperty(instance, name, {
+                        value: v.getFunction(),
+                        writable: !(attr & 1),
+                        enumerable: !(attr & 2),
+                        configurable: !(attr & 4)
+                    });
+                }
+            }
+            else {
+                Object.defineProperty(instance, name, {
+                    value: v,
+                    writable: !(attr & 1),
+                    enumerable: !(attr & 2),
+                    configurable: !(attr & 4)
+                });
+            }
+        });
+    }
+}
+
+//#endregion src/Template.ts
+
+//#region src/ObjectTemplate.ts
+function findHolder(obj, _target) {
+    return obj;
+}
+const internalField = new WeakMap();
+function getInternalFieldCount(instance) {
+    return internalField.get(instance)?.length ?? 0;
+}
+function getInternalField(instance, index) {
+    return internalField.get(instance)?.[index];
+}
+function setInternalField(instance, index, value) {
+    let fields = internalField.get(instance);
+    if (fields) {
+        fields[index] = value;
+    }
+    else {
+        fields = [];
+        fields[index] = value;
+        internalField.set(instance, fields);
+    }
+}
+class ObjectTemplate extends Template {
+    constructor(ctx, Ctor) {
+        super(ctx);
+        this.internalFieldCount = 0;
+        this._accessors = new Map();
+        this._instances = new WeakSet();
+        this.Ctor = Ctor ?? Object;
+    }
+    setAccessor(name, getterWrap, setterWrap, getter, setter, data, attribute, getterSideEffectType, setterSideEffectType) {
+        const config = {
+            name,
+            getterWrap,
+            setterWrap,
+            getter,
+            setter,
+            data,
+            attribute,
+            getterSideEffectType,
+            setterSideEffectType,
+            getterFunction: undefined,
+            setterFunction: undefined
+        };
+        config.getterFunction = getter
+            ? this._createAccessorWrapper('getter', config)
+            : undefined;
+        config.setterFunction = setter
+            ? this._createAccessorWrapper('setter', config)
+            : undefined;
+        this._accessors.set(name, config);
+    }
+    setInternalFieldCount(value) {
+        this.internalFieldCount = value;
+    }
+    _createAccessorWrapper(type, config) {
+        const { ctx } = this;
+        const instances = this._instances;
+        const resolveHolder = (receiver) => {
+            let holder = receiver;
+            while (holder != null && !instances.has(holder)) {
+                holder = Object.getPrototypeOf(holder);
+            }
+            return holder || receiver;
+        };
+        function accessor(value) {
+            const scope = ctx.openScope();
+            const callbackInfo = scope.callbackInfo;
+            let returnValue;
+            try {
+                callbackInfo.data = config.data;
+                callbackInfo.args = type === 'getter' ? [] : [value];
+                callbackInfo.thiz = this;
+                callbackInfo.holder = resolveHolder(this);
+                callbackInfo.fn = accessor;
+                const ret = type === 'getter'
+                    ? config.getterWrap(ctx.napiValueFromJsValue(config.name), ctx.getCurrentScope().id, config.getter)
+                    : config.setterWrap(ctx.napiValueFromJsValue(config.name), ctx.napiValueFromJsValue(value), ctx.getCurrentScope().id, config.setter);
+                returnValue = ret ? ctx.jsValueFromNapiValue(ret) : undefined;
+            }
+            catch (err) {
+                ctx.throwException(err);
+            }
+            ctx.closeScope(scope);
+            if (ctx.hasPendingException()) {
+                if (TryCatch.top) {
+                    TryCatch.top.setError(ctx.getAndClearLastException());
+                }
+                else {
+                    throw ctx.getAndClearLastException();
+                }
+            }
+            return returnValue;
+        }
+        return accessor;
+    }
+    applyToInstance(instance) {
+        this._instances.add(instance);
+        internalField.set(instance, Array(this.internalFieldCount));
+        this._addPropertiesToInstance(instance);
+        this._accessors.forEach((config, name) => {
+            Object.defineProperty(instance, name, {
+                get: config.getterFunction,
+                set: config.setterFunction,
+                enumerable: !(config.attribute & 2),
+                configurable: !(config.attribute & 4)
+            });
+        });
+    }
+    newInstance(_context) {
+        const { ctx, Ctor } = this;
+        let instance;
+        try {
+            instance = new Ctor();
+        }
+        catch (err) {
+            ctx.throwException(err);
+        }
+        this.applyToInstance(instance);
+        return instance;
+    }
+}
+
+//#endregion src/ObjectTemplate.ts
+
+//#region src/FunctionTemplate.ts
+class Signature {
+    constructor(receiver) {
+        this.receiver = receiver;
+    }
+}
+class FunctionTemplate extends Template {
+    constructor(ctx, callback, v8FunctionCallback, data, signature) {
+        super(ctx);
+        this.ctx = ctx;
+        this.callback = callback;
+        this.v8FunctionCallback = v8FunctionCallback;
+        this.data = data;
+        this.className = undefined;
+        this.signature = signature;
+        this._cached = [undefined];
+    }
+    setClassName(name) {
+        this.className = name;
+    }
+    instanceTemplate() {
+        if (!this._instanceTemplate) {
+            this._instanceTemplate = new ObjectTemplate(this.ctx);
+        }
+        return this._instanceTemplate;
+    }
+    prototypeTemplate() {
+        if (!this._prototypeTemplate) {
+            this._prototypeTemplate = new ObjectTemplate(this.ctx);
+        }
+        return this._prototypeTemplate;
+    }
+    getFunction() {
+        if (this._cached[0]) {
+            return this._cached[0];
+        }
+        const { ctx, callback, v8FunctionCallback, data, signature, _instanceTemplate } = this;
+        function _() {
+            if (signature && signature.receiver) {
+                const f = signature.receiver.getFunction();
+                if (!(this instanceof f)) {
+                    throw new TypeError('Illegal invocation');
+                }
+            }
+            const scope = ctx.openScope();
+            const callbackInfo = scope.callbackInfo;
+            let returnValue;
+            try {
+                callbackInfo.data = data;
+                callbackInfo.args = arguments;
+                callbackInfo.thiz = this;
+                callbackInfo.holder = findHolder(this, _) || this;
+                callbackInfo.fn = _;
+                if (_instanceTemplate && this instanceof _) {
+                    _instanceTemplate.applyToInstance(this);
+                }
+                const ret = callback(ctx.getCurrentScope().id, v8FunctionCallback);
+                returnValue = ret ? ctx.jsValueFromNapiValue(ret) : undefined;
+            }
+            catch (err) {
+                if (err !== 'unwind') {
+                    ctx.throwException(err);
+                }
+            }
+            finally {
+                ctx.closeScope(scope);
+            }
+            if (ctx.hasPendingException()) {
+                if (TryCatch.top) {
+                    TryCatch.top.setError(ctx.getAndClearLastException());
+                }
+                else {
+                    throw ctx.getAndClearLastException();
+                }
+            }
+            return returnValue;
+        }
+        if (typeof this.className === 'string') {
+            this.ctx.features.setFunctionName?.(_, this.className);
+        }
+        if (this._prototypeTemplate) {
+            this._prototypeTemplate.applyToInstance(_.prototype);
+        }
+        this._addPropertiesToInstance(_);
+        this._cached[0] = _;
+        return _;
+    }
+}
+
+//#endregion src/FunctionTemplate.ts
+
+//#region src/Private.ts
+const globalPrivateRegistry = new Map();
+const map = new WeakMap();
+class Private {
+    constructor(name) {
+        this._name = name;
+    }
+    name() {
+        return this._name;
+    }
+    static forApi(name) {
+        let privateInstance = globalPrivateRegistry.get(name);
+        if (!privateInstance) {
+            privateInstance = new Private(name);
+            globalPrivateRegistry.set(name, privateInstance);
+        }
+        return privateInstance;
+    }
+}
+function setPrivate(obj, key, value) {
+    if (!(key instanceof Private)) {
+        throw new TypeError('Expected key to be an instance of Private');
+    }
+    let m = map.get(key);
+    if (!m) {
+        m = new WeakMap();
+        map.set(key, m);
+    }
+    m.set(obj, value);
+}
+function getPrivate(obj, key) {
+    if (!(key instanceof Private)) {
+        throw new TypeError('Expected key to be an instance of Private');
+    }
+    const m = map.get(key);
+    if (!m) {
+        return undefined;
+    }
+    return m.get(obj);
+}
+function hasPrivate(obj, key) {
+    if (!(key instanceof Private)) {
+        throw new TypeError('Expected key to be an instance of Private');
+    }
+    const m = map.get(key);
+    if (!m) {
+        return false;
+    }
+    return m.has(obj);
+}
+function deletePrivate(obj, key) {
+    if (!(key instanceof Private)) {
+        throw new TypeError('Expected key to be an instance of Private');
+    }
+    const m = map.get(key);
+    if (!m || !m.has(obj)) {
+        return true;
+    }
+    return m.delete(obj);
+}
+
+//#endregion src/Private.ts
+
+//#region src/ExternalMemory.ts
+const kMaxReasonableBytes = BigInt(1) << BigInt(60);
+const kMinReasonableBytes = -kMaxReasonableBytes;
+class ExternalMemory {
+    constructor(onChange) {
+        this.total = BigInt(0);
+        this.onChange = onChange ?? null;
+    }
+    adjust(changeInBytes) {
+        changeInBytes = BigInt(changeInBytes);
+        if (!(kMinReasonableBytes <= changeInBytes && changeInBytes < kMaxReasonableBytes)) {
+            throw new RangeError(`changeInBytes ${changeInBytes} is out of reasonable range`);
+        }
+        const old = this.total;
+        this.total += changeInBytes;
+        const amount = this.total;
+        const onChange = this.onChange;
+        if (changeInBytes) {
+            onChange?.(amount, old, changeInBytes);
+        }
+        return amount;
+    }
+}
+
+//#endregion src/ExternalMemory.ts
+
+//#region src/Isolate.ts
+class Isolate {
+    constructor(options) {
+        this.features = detectFeatures(options?.features);
+        this._globalThis = this.features.getGlobalThis();
+        this._scopeStore = new ScopeStore();
+        this._handleStore = new HandleStore(this.features);
+        this.globalHandleStore = new PersistentStore();
+        this._lastException = new Persistent(this);
+        this._externalMemory = new ExternalMemory(options?.onExternalMemoryChange);
+    }
+    napiValueFromJsValue(value) {
+        switch (value) {
+            case undefined: return 2;
+            case null: return 3;
+            case false: return 4;
+            case true: return 5;
+            case '': return 7;
+            case this._globalThis: return 6;
+            default: return this._scopeStore.currentScope.add(value);
+        }
+    }
+    jsValueFromNapiValue(napiValue) {
+        return this._handleStore.deepDeref(napiValue);
+    }
+    deleteRefSlotValue(id) {
+        this._handleStore.refValues.delete(Number(id));
+    }
+    getRefSlotValue(id) {
+        return this._handleStore.refValues.get(Number(id));
+    }
+    setRefSlotValue(id, ref) {
+        this._handleStore.refValues.set(Number(id), ref);
+    }
+    createReference(...args) {
+        return new Persistent(this, ...args);
+    }
+    insertRef(persistent) {
+        this.globalHandleStore.insert(persistent);
+    }
+    getRef(ref) {
+        return this.globalHandleStore.deref(ref);
+    }
+    removeRef(ref, force = false) {
+        if (force || this._scopeStore.isEmpty()) {
+            const persistent = this.globalHandleStore.deref(ref);
+            persistent?.dispose();
+        }
+        else {
+            this.globalHandleStore.markUnused(ref);
+        }
+    }
+    getTryCatch(address) {
+        return TryCatch.deref(address);
+    }
+    pushTryCatch(address) {
+        const tryCatch = new TryCatch(address);
+        return tryCatch;
+    }
+    popTryCatch(address) {
+        if (address !== TryCatch.top?.id) {
+            throw new Error('TryCatch mismatch');
+        }
+        return TryCatch.pop();
+    }
+    setLastException(err) {
+        this._lastException.resetTo(err);
+    }
+    throwException(err) {
+        if (TryCatch.top) {
+            TryCatch.top.setError(err);
+        }
+        else {
+            this.setLastException(err);
+        }
+        return err;
+    }
+    hasPendingException() {
+        return !this._lastException.isEmpty();
+    }
+    getAndClearLastException() {
+        const err = this._lastException.deref();
+        this._lastException.reset();
+        return err;
+    }
+    adjustAmountOfExternalAllocatedMemory(changeInBytes) {
+        return this._externalMemory.adjust(changeInBytes);
+    }
+    createSignature(template) {
+        return new Signature(template);
+    }
+    createObjectTemplate(constructor) {
+        return new ObjectTemplate(this, constructor);
+    }
+    setInternalField(obj, index, value) {
+        setInternalField(obj, index, value);
+    }
+    getInternalField(obj, index) {
+        return getInternalField(obj, index);
+    }
+    getInternalFieldCount(obj) {
+        return getInternalFieldCount(obj);
+    }
+    createFunctionTemplate(callback, v8FunctionCallback, data, signature) {
+        const functionTemplate = new FunctionTemplate(this, callback, v8FunctionCallback, data, signature);
+        return functionTemplate;
+    }
+    isScopeEmpty() {
+        return this._scopeStore.isEmpty();
+    }
+    getCurrentScope() {
+        return this._scopeStore.currentScope;
+    }
+    openScope() {
+        return this._scopeStore.openScope(this._handleStore);
+    }
+    closeScope(_scope) {
+        this._scopeStore.closeScope();
+        if (this.isScopeEmpty()) {
+            this.globalHandleStore.recycle();
+        }
+    }
+    getHandleScope(scope) {
+        return this._scopeStore.deref(scope);
+    }
+    getCallbackInfo(info) {
+        return this._scopeStore.deref(info).callbackInfo;
+    }
+    createExternal(data) {
+        return new External(data);
+    }
+    getExternalValue(external) {
+        return getExternalValue(external);
+    }
+    isExternal(value) {
+        return isExternal(value);
+    }
+    createResolver() {
+        return this.features.withResolvers.call(Promise);
+    }
+    createPrivate(name) {
+        return new Private(name);
+    }
+    getOrCreateGlobalPrivate(name) {
+        return Private.forApi(name);
+    }
+    setPrivate(obj, key, value) {
+        return setPrivate(obj, key, value);
+    }
+    getPrivate(obj, key) {
+        return getPrivate(obj, key);
+    }
+    hasPrivate(obj, key) {
+        return hasPrivate(obj, key);
+    }
+    deletePrivate(obj, key) {
+        return deletePrivate(obj, key);
+    }
+}
+
+//#endregion src/Isolate.ts
+
+//#region src/Context.ts
+const callbackWrapper = (envObject, callback) => {
+    const napiValue = envObject.callIntoModule(callback);
+    return (!napiValue) ? undefined : envObject.ctx.jsValueFromNapiValue(napiValue);
+};
+const withScope = (envObject, thiz, args, data, getFunction, wrapper, callback) => {
+    const scope = envObject.ctx.openScope(envObject);
+    const callbackInfo = scope.callbackInfo;
+    callbackInfo.data = data;
+    callbackInfo.args = args;
+    callbackInfo.thiz = thiz;
+    callbackInfo.fn = getFunction;
+    try {
+        return wrapper(envObject, callback);
+    }
+    catch (e) {
+        if (e !== 'unwind') {
+            throw e;
+        }
+    }
+    finally {
+        envObject.ctx.closeScope(envObject, scope);
+    }
+};
+class CleanupHookCallback {
+    constructor(envObject, fn, arg) {
+        this.envObject = envObject;
+        this.fn = fn;
+        this.arg = arg;
+    }
+}
+class CleanupQueue {
+    constructor() {
+        this._cleanupHooks = [];
+    }
+    empty() {
+        return this._cleanupHooks.length === 0;
+    }
+    add(envObject, fn, arg) {
+        if (this._cleanupHookIndex === undefined) {
+            for (let i = 0; i < this._cleanupHooks.length; ++i) {
+                const hook = this._cleanupHooks[i];
+                if (hook.envObject === envObject && hook.fn === fn && hook.arg === arg) {
+                    throw new Error('Can not add same fn and arg twice');
+                }
+            }
+            this._cleanupHooks.push(new CleanupHookCallback(envObject, fn, arg));
+            if (this._cleanupHooks.length > CleanupQueue.INDEX_THRESHOLD) {
+                this._createIndex();
+            }
+            return;
+        }
+        let envHooks = this._cleanupHookIndex.get(envObject);
+        if (envHooks === undefined) {
+            envHooks = new Map();
+            this._cleanupHookIndex.set(envObject, envHooks);
+        }
+        let args = envHooks.get(fn);
+        if (args === undefined) {
+            args = new Set();
+            envHooks.set(fn, args);
+        }
+        else if (args.has(arg)) {
+            throw new Error('Can not add same fn and arg twice');
+        }
+        args.add(arg);
+        this._cleanupHooks.push(new CleanupHookCallback(envObject, fn, arg));
+    }
+    remove(envObject, fn, arg) {
+        for (let i = 0; i < this._cleanupHooks.length; ++i) {
+            const hook = this._cleanupHooks[i];
+            if (hook.envObject === envObject && hook.fn === fn && hook.arg === arg) {
+                this._cleanupHooks.splice(i, 1);
+                this._deleteIndex(hook);
+                return;
+            }
+        }
+    }
+    drain() {
+        const hooks = this._cleanupHooks.slice();
+        for (let i = hooks.length - 1; i >= 0; --i) {
+            const cb = hooks[i];
+            if (typeof cb.fn === 'number') {
+                cb.envObject.bridge.makeDynCall_vp(cb.fn)(cb.arg);
+            }
+            else {
+                cb.fn(cb.arg);
+            }
+            const lastIndex = this._cleanupHooks.length - 1;
+            if (this._cleanupHooks[lastIndex] === cb) {
+                this._cleanupHooks.pop();
+                this._deleteIndex(cb);
+            }
+            else {
+                const index = this._cleanupHooks.lastIndexOf(cb);
+                if (index !== -1) {
+                    this._cleanupHooks.splice(index, 1);
+                    this._deleteIndex(cb);
+                }
+            }
+        }
+        if (this._cleanupHooks.length === 0) {
+            this._cleanupHookIndex = undefined;
+        }
+    }
+    _createIndex() {
+        const index = new WeakMap();
+        for (let i = 0; i < this._cleanupHooks.length; ++i) {
+            const hook = this._cleanupHooks[i];
+            let envHooks = index.get(hook.envObject);
+            if (envHooks === undefined) {
+                envHooks = new Map();
+                index.set(hook.envObject, envHooks);
+            }
+            let args = envHooks.get(hook.fn);
+            if (args === undefined) {
+                args = new Set();
+                envHooks.set(hook.fn, args);
+            }
+            args.add(hook.arg);
+        }
+        this._cleanupHookIndex = index;
+    }
+    _deleteIndex(hook) {
+        if (this._cleanupHookIndex === undefined)
+            return;
+        const envHooks = this._cleanupHookIndex.get(hook.envObject);
+        const args = envHooks.get(hook.fn);
+        args.delete(hook.arg);
+        if (args.size === 0)
+            envHooks.delete(hook.fn);
+        if (envHooks.size === 0)
+            this._cleanupHookIndex.delete(hook.envObject);
+    }
+    dispose() {
+        this._cleanupHooks.length = 0;
+        this._cleanupHookIndex = undefined;
+    }
+}
+CleanupQueue.INDEX_THRESHOLD = 16;
+class NodejsWaitingRequestCounter {
+    constructor(MessageChannel) {
+        this.refHandle = new MessageChannel().port1;
+        this.count = 0;
+    }
+    increase() {
+        if (this.count === 0) {
+            if (this.refHandle.ref) {
+                this.refHandle.ref();
+            }
+        }
+        this.count++;
+    }
+    decrease() {
+        if (this.count === 0)
+            return;
+        if (this.count === 1) {
+            if (this.refHandle.unref) {
+                this.refHandle.unref();
+            }
+        }
+        this.count--;
+    }
+}
+class Context {
+    constructor(options) {
+        this._isStopping = false;
+        this._canCallIntoJs = true;
+        this._suppressDestroy = false;
+        this.envStore = new ArrayStore();
+        this.refStore = new Map();
+        this.isolate = new Isolate(options);
+        this.features = this.isolate.features;
+        this.cleanupQueue = new CleanupQueue();
+        if (typeof process === 'object' && process !== null && typeof process.once === 'function' && this.features.MessageChannel) {
+            this.refCounter = new NodejsWaitingRequestCounter(this.features.MessageChannel);
+            process.once('beforeExit', () => {
+                if (!this._suppressDestroy) {
+                    this.destroy();
+                }
+            });
+        }
+    }
+    getIsolate() {
+        return this.isolate;
+    }
+    suppressDestroy() {
+        this._suppressDestroy = true;
+    }
+    getRuntimeVersions() {
+        return {
+            version,
+            NODE_API_SUPPORTED_VERSION_MAX,
+            NAPI_VERSION_EXPERIMENTAL,
+            NODE_API_DEFAULT_MODULE_API_VERSION,
+            NODE_MODULE_VERSION
+        };
+    }
+    createNotSupportWeakRefError(api, message) {
+        return new NotSupportWeakRefError(api, message);
+    }
+    createNotSupportBufferError(api, message) {
+        return new NotSupportBufferError(api, message);
+    }
+    createReference(envObject, handle_id, initialRefcount, ownership) {
+        return Reference.create(this, envObject, handle_id, initialRefcount, ownership);
+    }
+    createReferenceWithData(envObject, handle_id, initialRefcount, ownership, data) {
+        return ReferenceWithData.create(this, envObject, handle_id, initialRefcount, ownership, data);
+    }
+    createReferenceWithFinalizer(envObject, handle_id, initialRefcount, ownership, finalize_callback = 0, finalize_data = 0, finalize_hint = 0) {
+        return ReferenceWithFinalizer.create(this, envObject, handle_id, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint);
+    }
+    createResolver() {
+        return this.isolate.createResolver();
+    }
+    adjustAmountOfExternalAllocatedMemory(changeInBytes) {
+        return this.isolate.adjustAmountOfExternalAllocatedMemory(changeInBytes);
+    }
+    createEnv(filename, moduleApiVersion, bridge, nodeBinding) {
+        moduleApiVersion = typeof moduleApiVersion !== 'number' ? NODE_API_DEFAULT_MODULE_API_VERSION : moduleApiVersion;
+        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) {
+            const errorMessage = `${filename} requires Node-API version ${moduleApiVersion}, but this version of Node.js only supports version ${NODE_API_SUPPORTED_VERSION_MAX} add-ons.`;
+            throw new Error(errorMessage);
+        }
+        const env = new NodeEnv(this, this.envStore, { ...bridge });
+        env.filename = filename;
+        env.moduleApiVersion = moduleApiVersion;
+        env.nodeBinding = nodeBinding;
+        this.addCleanupHook(env, () => { env.unref(); }, 0);
+        return env;
+    }
+    createFunction(envObject, napiCallback, data, name, dynamicExecution) {
+        if (envObject.ctx !== this) {
+            throw new Error(`The napi_env (${envObject.bridge.address}) is not created by this context`);
+        }
+        const callback = (envObject) => {
+            return napiCallback(envObject.bridge.address, envObject.ctx.getCurrentScope().id);
+        };
+        let _;
+        const staticFunctionWrapper = (withScope, envObject, data, callbackWrapper, callback) => {
+            return function () {
+                return withScope(envObject, this, arguments, data, _, callbackWrapper, callback);
+            };
+        };
+        let functionWrapper;
+        if (name && dynamicExecution && this.features.makeDynamicFunction) {
+            try {
+                functionWrapper = this.features.makeDynamicFunction('withScope', 'envObject', 'data', 'callbackWrapper', 'callback', 'return function ' + name + '(){' +
+                    'return withScope(envObject,this,arguments,data,' + name + ',callbackWrapper,callback)' +
+                    '};');
+            }
+            catch (_) {
+                functionWrapper = staticFunctionWrapper;
+            }
+        }
+        else {
+            functionWrapper = staticFunctionWrapper;
+        }
+        _ = functionWrapper(withScope, envObject, data, callbackWrapper, callback);
+        if (functionWrapper === staticFunctionWrapper && this.features.setFunctionName && name) {
+            this.features.setFunctionName(_, name);
+        }
+        return _;
+    }
+    createTrackedFinalizer(envObject, finalize_callback, finalize_data, finalize_hint) {
+        return TrackedFinalizer.create(envObject, finalize_callback, finalize_data, finalize_hint);
+    }
+    getCurrentScope() {
+        return this.isolate.getCurrentScope();
+    }
+    openScope(envObject) {
+        const scope = this.isolate.openScope();
+        envObject.openHandleScopes++;
+        return scope;
+    }
+    closeScope(envObject, scope) {
+        this.isolate.closeScope(scope);
+        envObject.openHandleScopes--;
+    }
+    getEnv(env) {
+        return this.envStore.deref(env);
+    }
+    getRef(ref) {
+        return this.refStore.get(Number(ref));
+    }
+    getHandleScope(scope) {
+        return this.isolate.getHandleScope(scope);
+    }
+    getCallbackInfo(info) {
+        return this.isolate.getCallbackInfo(info);
+    }
+    napiValueFromJsValue(value) {
+        return this.isolate.napiValueFromJsValue(value);
+    }
+    jsValueFromNapiValue(napiValue) {
+        return this.isolate.jsValueFromNapiValue(napiValue);
+    }
+    createExternal(data) {
+        return this.isolate.createExternal(data);
+    }
+    getExternalValue(external) {
+        return this.isolate.getExternalValue(external);
+    }
+    isExternal(value) {
+        return this.isolate.isExternal(value);
+    }
+    addCleanupHook(envObject, fn, arg) {
+        this.cleanupQueue.add(envObject, fn, arg);
+    }
+    removeCleanupHook(envObject, fn, arg) {
+        this.cleanupQueue.remove(envObject, fn, arg);
+    }
+    runCleanup() {
+        while (!this.cleanupQueue.empty()) {
+            this.cleanupQueue.drain();
+        }
+    }
+    increaseWaitingRequestCounter() {
+        this.refCounter?.increase();
+    }
+    decreaseWaitingRequestCounter() {
+        this.refCounter?.decrease();
+    }
+    setCanCallIntoJs(value) {
+        this._canCallIntoJs = value;
+    }
+    setStopping(value) {
+        this._isStopping = value;
+    }
+    canCallIntoJs() {
+        return this._canCallIntoJs && !this._isStopping;
+    }
+    getDylinkMetadata(binary) {
+        return getDylinkMetadata(binary);
+    }
+    destroy() {
+        this.setStopping(true);
+        this.setCanCallIntoJs(false);
+        this.runCleanup();
+    }
+}
+let defaultContext;
+function createContext(options) {
+    return new Context(options);
+}
+function getDefaultContext() {
+    if (!defaultContext) {
+        defaultContext = createContext();
+    }
+    return defaultContext;
+}
+
+//#endregion src/Context.ts
+
+export { ArrayStore, BaseArrayStore, Context, CountIdAllocator, CountIdReuseAllocator, Disposable, EmnapiError, Env, External, Finalizer, FunctionTemplate, HandleScope, HandleStore, Isolate, NAPI_VERSION_EXPERIMENTAL, NODE_API_DEFAULT_MODULE_API_VERSION, NODE_API_SUPPORTED_VERSION_MAX, NODE_API_SUPPORTED_VERSION_MIN, NodeEnv, NotSupportBufferError, NotSupportWeakRefError, ObjectTemplate, Persistent, PersistentStore, Private, RefTracker, Reference, ReferenceOwnership, ReferenceWithData, ReferenceWithFinalizer, ScopeStore, Signature, StrongRef, Template, TrackedFinalizer, TryCatch, createContext, deletePrivate, getDefaultContext, getDylinkMetadata, getExternalValue, getInternalField, getPrivate, hasPrivate, isExternal, isReferenceType, setInternalField, setPrivate, version };
+//# sourceMappingURL=emnapi.js.map