@cortexkit/pi-magic-context 0.44.4 → 0.45.0

package/dist/{module-asyncify-2EFITU5U-rkqjhjxd.js → index-g20jdh0p.js}

@@ -1,10 +1,17 @@
-import {
-  EvalFlags,
-  IntrinsicsFlags,
-  JSPromiseStateEnum,
-  GetOwnPropertyNamesFlags,
-  IsEqualOp
-} from "./index-rn7gafjr.js";
+// ../../node_modules/.bun/@jitl+quickjs-ffi-types@0.32.0/node_modules/@jitl/quickjs-ffi-types/dist/index.mjs
+function assertSync2(fn) {
+  return function(...args) {
+    let result = fn(...args);
+    if (result && typeof result == "object" && result instanceof Promise)
+      throw new Error("Function unexpectedly returned a Promise");
+    return result;
+  };
+}
+var EvalFlags2 = { JS_EVAL_TYPE_GLOBAL: 0, JS_EVAL_TYPE_MODULE: 1, JS_EVAL_TYPE_DIRECT: 2, JS_EVAL_TYPE_INDIRECT: 3, JS_EVAL_TYPE_MASK: 3, JS_EVAL_FLAG_STRICT: 8, JS_EVAL_FLAG_STRIP: 16, JS_EVAL_FLAG_COMPILE_ONLY: 32, JS_EVAL_FLAG_BACKTRACE_BARRIER: 64 };
+var IntrinsicsFlags2 = { BaseObjects: 1, Date: 2, Eval: 4, StringNormalize: 8, RegExp: 16, RegExpCompiler: 32, JSON: 64, Proxy: 128, MapSet: 256, TypedArrays: 512, Promise: 1024, BigInt: 2048, BigFloat: 4096, BigDecimal: 8192, OperatorOverloading: 16384, BignumExt: 32768 };
+var JSPromiseStateEnum2 = { Pending: 0, Fulfilled: 1, Rejected: 2 };
+var GetOwnPropertyNamesFlags2 = { JS_GPN_STRING_MASK: 1, JS_GPN_SYMBOL_MASK: 2, JS_GPN_PRIVATE_MASK: 4, JS_GPN_ENUM_ONLY: 16, JS_GPN_SET_ENUM: 32, QTS_GPN_NUMBER_MASK: 64, QTS_STANDARD_COMPLIANT_NUMBER: 128 };
+var IsEqualOp2 = { IsStrictlyEqual: 0, IsSameValue: 1, IsSameValueZero: 2 };
 
 // ../../node_modules/.bun/quickjs-emscripten-core@0.32.0/node_modules/quickjs-emscripten-core/dist/chunk-V2S4ZYJR.mjs
 var __defProp = Object.defineProperty;
@@ -13,7 +20,10 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 var QTS_DEBUG = false;
-function debugLog(...args) {
+function setDebugMode2(enabled = true) {
+  QTS_DEBUG = enabled;
+}
+function debugLog2(...args) {
   QTS_DEBUG && console.log("quickjs-emscripten:", ...args);
 }
 var errors_exports = {};
@@ -123,17 +133,17 @@ function awaitEachYieldedPromise(gen) {
   }
   return handleNextStep(gen.next());
 }
-var UsingDisposable = class {
+var UsingDisposable2 = class {
   [Symbol.dispose]() {
     return this.dispose();
   }
 };
 var SymbolDispose = Symbol.dispose ?? Symbol.for("Symbol.dispose");
-var prototypeAsAny = UsingDisposable.prototype;
+var prototypeAsAny = UsingDisposable2.prototype;
 prototypeAsAny[SymbolDispose] || (prototypeAsAny[SymbolDispose] = function() {
   return this.dispose();
 });
-var Lifetime = class _Lifetime extends UsingDisposable {
+var Lifetime2 = class _Lifetime extends UsingDisposable2 {
   constructor(_value, copier, disposer, _owner) {
     super();
     this._value = _value;
@@ -181,7 +191,7 @@ ${this._constructorStack}
 Lifetime used`) : new QuickJSUseAfterFree("Lifetime not alive");
   }
 };
-var StaticLifetime = class extends Lifetime {
+var StaticLifetime2 = class extends Lifetime2 {
   constructor(value, owner) {
     super(value, undefined, undefined, owner);
   }
@@ -193,7 +203,7 @@ var StaticLifetime = class extends Lifetime {
   }
   dispose() {}
 };
-var WeakLifetime = class extends Lifetime {
+var WeakLifetime2 = class extends Lifetime2 {
   constructor(value, copier, disposer, owner) {
     super(value, copier, disposer, owner);
   }
@@ -214,10 +224,10 @@ function scopeFinally(scope, blockError) {
   if (blockError || disposeError)
     throw blockError || disposeError;
 }
-var Scope = class _Scope extends UsingDisposable {
+var Scope2 = class _Scope extends UsingDisposable2 {
   constructor() {
     super(...arguments);
-    this._disposables = new Lifetime(new Set);
+    this._disposables = new Lifetime2(new Set);
     this.manage = (lifetime) => (this._disposables.value.add(lifetime), lifetime);
   }
   static withScope(block) {
@@ -262,7 +272,7 @@ var Scope = class _Scope extends UsingDisposable {
     this._disposables.dispose();
   }
 };
-function createDisposableArray(items) {
+function createDisposableArray2(items) {
   let array = items ? Array.from(items) : [];
   function disposeAlive() {
     return array.forEach((disposable) => disposable.alive ? disposable.dispose() : undefined);
@@ -275,18 +285,18 @@ function createDisposableArray(items) {
 function isDisposable(value) {
   return !!(value && (typeof value == "object" || typeof value == "function") && ("alive" in value) && typeof value.alive == "boolean" && ("dispose" in value) && typeof value.dispose == "function");
 }
-var AbstractDisposableResult = class _AbstractDisposableResult extends UsingDisposable {
+var AbstractDisposableResult = class _AbstractDisposableResult extends UsingDisposable2 {
   static success(value) {
-    return new DisposableSuccess(value);
+    return new DisposableSuccess2(value);
   }
   static fail(error, onUnwrap) {
-    return new DisposableFail(error, onUnwrap);
+    return new DisposableFail2(error, onUnwrap);
   }
   static is(result) {
     return result instanceof _AbstractDisposableResult;
   }
 };
-var DisposableSuccess = class extends AbstractDisposableResult {
+var DisposableSuccess2 = class extends AbstractDisposableResult {
   constructor(value) {
     super();
     this.value = value;
@@ -304,7 +314,7 @@ var DisposableSuccess = class extends AbstractDisposableResult {
     return this.value;
   }
 };
-var DisposableFail = class extends AbstractDisposableResult {
+var DisposableFail2 = class extends AbstractDisposableResult {
   constructor(error, onUnwrap) {
     super();
     this.error = error;
@@ -323,8 +333,8 @@ var DisposableFail = class extends AbstractDisposableResult {
     return fallback;
   }
 };
-var DisposableResult = AbstractDisposableResult;
-var QuickJSDeferredPromise = class extends UsingDisposable {
+var DisposableResult2 = AbstractDisposableResult;
+var QuickJSDeferredPromise2 = class extends UsingDisposable2 {
   constructor(args) {
     super();
     this.resolve = (value) => {
@@ -353,22 +363,22 @@ var ModuleMemory = class {
   }
   toPointerArray(handleArray) {
     let typedArray = new Int32Array(handleArray.map((handle) => handle.value)), numBytes = typedArray.length * typedArray.BYTES_PER_ELEMENT, ptr = this.module._malloc(numBytes);
-    return new Uint8Array(this.module.HEAPU8.buffer, ptr, numBytes).set(new Uint8Array(typedArray.buffer)), new Lifetime(ptr, undefined, (ptr2) => this.module._free(ptr2));
+    return new Uint8Array(this.module.HEAPU8.buffer, ptr, numBytes).set(new Uint8Array(typedArray.buffer)), new Lifetime2(ptr, undefined, (ptr2) => this.module._free(ptr2));
   }
   newTypedArray(kind, length) {
     let zeros = new kind(new Array(length).fill(0)), numBytes = zeros.length * zeros.BYTES_PER_ELEMENT, ptr = this.module._malloc(numBytes), typedArray = new kind(this.module.HEAPU8.buffer, ptr, length);
-    return typedArray.set(zeros), new Lifetime({ typedArray, ptr }, undefined, (value) => this.module._free(value.ptr));
+    return typedArray.set(zeros), new Lifetime2({ typedArray, ptr }, undefined, (value) => this.module._free(value.ptr));
   }
   newMutablePointerArray(length) {
     return this.newTypedArray(Int32Array, length);
   }
   newHeapCharPointer(string) {
     let strlen = this.module.lengthBytesUTF8(string), dataBytes = strlen + 1, ptr = this.module._malloc(dataBytes);
-    return this.module.stringToUTF8(string, ptr, dataBytes), new Lifetime({ ptr, strlen }, undefined, (value) => this.module._free(value.ptr));
+    return this.module.stringToUTF8(string, ptr, dataBytes), new Lifetime2({ ptr, strlen }, undefined, (value) => this.module._free(value.ptr));
   }
   newHeapBufferPointer(buffer) {
     let numBytes = buffer.byteLength, ptr = this.module._malloc(numBytes);
-    return this.module.HEAPU8.set(buffer, ptr), new Lifetime({ pointer: ptr, numBytes }, undefined, (value) => this.module._free(value.pointer));
+    return this.module.HEAPU8.set(buffer, ptr), new Lifetime2({ pointer: ptr, numBytes }, undefined, (value) => this.module._free(value.pointer));
   }
   consumeHeapCharPointer(ptr) {
     let str = this.module.UTF8ToString(ptr);
@@ -376,15 +386,15 @@ var ModuleMemory = class {
   }
 };
 var UnstableSymbol = Symbol("Unstable");
-var DefaultIntrinsics = Object.freeze({ BaseObjects: true, Date: true, Eval: true, StringNormalize: true, RegExp: true, JSON: true, Proxy: true, MapSet: true, TypedArrays: true, Promise: true });
+var DefaultIntrinsics2 = Object.freeze({ BaseObjects: true, Date: true, Eval: true, StringNormalize: true, RegExp: true, JSON: true, Proxy: true, MapSet: true, TypedArrays: true, Promise: true });
 function intrinsicsToFlags(intrinsics) {
   if (!intrinsics)
     return 0;
   let result = 0;
   for (let [maybeIntrinsicName, enabled] of Object.entries(intrinsics)) {
-    if (!(maybeIntrinsicName in IntrinsicsFlags))
+    if (!(maybeIntrinsicName in IntrinsicsFlags2))
       throw new QuickJSUnknownIntrinsic(maybeIntrinsicName);
-    enabled && (result |= IntrinsicsFlags[maybeIntrinsicName]);
+    enabled && (result |= IntrinsicsFlags2[maybeIntrinsicName]);
   }
   return result;
 }
@@ -394,7 +404,7 @@ function evalOptionsToFlags(evalOptions) {
   if (evalOptions === undefined)
     return 0;
   let { type, strict, strip, compileOnly, backtraceBarrier } = evalOptions, flags = 0;
-  return type === "global" && (flags |= EvalFlags.JS_EVAL_TYPE_GLOBAL), type === "module" && (flags |= EvalFlags.JS_EVAL_TYPE_MODULE), strict && (flags |= EvalFlags.JS_EVAL_FLAG_STRICT), strip && (flags |= EvalFlags.JS_EVAL_FLAG_STRIP), compileOnly && (flags |= EvalFlags.JS_EVAL_FLAG_COMPILE_ONLY), backtraceBarrier && (flags |= EvalFlags.JS_EVAL_FLAG_BACKTRACE_BARRIER), flags;
+  return type === "global" && (flags |= EvalFlags2.JS_EVAL_TYPE_GLOBAL), type === "module" && (flags |= EvalFlags2.JS_EVAL_TYPE_MODULE), strict && (flags |= EvalFlags2.JS_EVAL_FLAG_STRICT), strip && (flags |= EvalFlags2.JS_EVAL_FLAG_STRIP), compileOnly && (flags |= EvalFlags2.JS_EVAL_FLAG_COMPILE_ONLY), backtraceBarrier && (flags |= EvalFlags2.JS_EVAL_FLAG_BACKTRACE_BARRIER), flags;
 }
 function getOwnPropertyNamesOptionsToFlags(options) {
   if (typeof options == "number")
@@ -402,7 +412,7 @@ function getOwnPropertyNamesOptionsToFlags(options) {
   if (options === undefined)
     return 0;
   let { strings: includeStrings, symbols: includeSymbols, quickjsPrivate: includePrivate, onlyEnumerable, numbers: includeNumbers, numbersAsStrings } = options, flags = 0;
-  return includeStrings && (flags |= GetOwnPropertyNamesFlags.JS_GPN_STRING_MASK), includeSymbols && (flags |= GetOwnPropertyNamesFlags.JS_GPN_SYMBOL_MASK), includePrivate && (flags |= GetOwnPropertyNamesFlags.JS_GPN_PRIVATE_MASK), onlyEnumerable && (flags |= GetOwnPropertyNamesFlags.JS_GPN_ENUM_ONLY), includeNumbers && (flags |= GetOwnPropertyNamesFlags.QTS_GPN_NUMBER_MASK), numbersAsStrings && (flags |= GetOwnPropertyNamesFlags.QTS_STANDARD_COMPLIANT_NUMBER), flags;
+  return includeStrings && (flags |= GetOwnPropertyNamesFlags2.JS_GPN_STRING_MASK), includeSymbols && (flags |= GetOwnPropertyNamesFlags2.JS_GPN_SYMBOL_MASK), includePrivate && (flags |= GetOwnPropertyNamesFlags2.JS_GPN_PRIVATE_MASK), onlyEnumerable && (flags |= GetOwnPropertyNamesFlags2.JS_GPN_ENUM_ONLY), includeNumbers && (flags |= GetOwnPropertyNamesFlags2.QTS_GPN_NUMBER_MASK), numbersAsStrings && (flags |= GetOwnPropertyNamesFlags2.QTS_STANDARD_COMPLIANT_NUMBER), flags;
 }
 function concat(...values) {
   let result = [];
@@ -410,7 +420,7 @@ function concat(...values) {
     value !== undefined && (result = result.concat(value));
   return result;
 }
-var QuickJSIterator = class extends UsingDisposable {
+var QuickJSIterator = class extends UsingDisposable2 {
   constructor(handle, context) {
     super();
     this.handle = handle;
@@ -439,7 +449,7 @@ var QuickJSIterator = class extends UsingDisposable {
   throw(e) {
     if (!this.alive)
       return { done: true, value: undefined };
-    let errorHandle = e instanceof Lifetime ? e : this.context.newError(e), throwMethod = this.context.getProp(this.handle, "throw"), result = this.callIteratorMethod(throwMethod, e);
+    let errorHandle = e instanceof Lifetime2 ? e : this.context.newError(e), throwMethod = this.context.getProp(this.handle, "throw"), result = this.callIteratorMethod(throwMethod, e);
     return errorHandle.alive && errorHandle.dispose(), throwMethod.dispose(), this.dispose(), result;
   }
   get alive() {
@@ -453,7 +463,7 @@ var QuickJSIterator = class extends UsingDisposable {
     if (callResult.error)
       return this.dispose(), { value: callResult };
     let done = this.context.getProp(callResult.value, "done").consume((v) => this.context.dump(v)), value = this.context.getProp(callResult.value, "value");
-    return callResult.value.dispose(), done && this.dispose(), { value: DisposableResult.success(value), done };
+    return callResult.value.dispose(), done && this.dispose(), { value: DisposableResult2.success(value), done };
   }
 };
 var INT32_MIN = -2147483648;
@@ -499,7 +509,7 @@ var HostRefMap = class {
     return this.nextId++;
   }
 };
-var HostRef = class extends UsingDisposable {
+var HostRef = class extends UsingDisposable2 {
   constructor(runtime, handle, id) {
     if (id === INVALID_HOST_REF_ID)
       throw new QuickJSHostRefInvalid("cannot create HostRef with undefined id");
@@ -521,7 +531,7 @@ var HostRef = class extends UsingDisposable {
 var ContextMemory = class extends ModuleMemory {
   constructor(args) {
     super(args.module);
-    this.scope = new Scope;
+    this.scope = new Scope2;
     this.copyJSValue = (ptr) => this.ffi.QTS_DupValuePointer(this.ctx.value, ptr);
     this.freeJSValue = (ptr) => {
       this.ffi.QTS_FreeValuePointer(this.ctx.value, ptr);
@@ -548,13 +558,13 @@ var ContextMemory = class extends ModuleMemory {
     let dispose = extraDispose ? (val) => {
       extraDispose(), this.freeJSValue(val);
     } : this.freeJSValue;
-    return new Lifetime(ptr, this.copyJSValue, dispose, this.owner);
+    return new Lifetime2(ptr, this.copyJSValue, dispose, this.owner);
   }
   staticHeapValueHandle(ptr) {
-    return this.manage(this.heapValueHandle(ptr)), new StaticLifetime(ptr, this.owner);
+    return this.manage(this.heapValueHandle(ptr)), new StaticLifetime2(ptr, this.owner);
   }
 };
-var QuickJSContext = class extends UsingDisposable {
+var QuickJSContext2 = class extends UsingDisposable2 {
   constructor(args) {
     super();
     this._undefined = undefined;
@@ -570,18 +580,18 @@ var QuickJSContext = class extends UsingDisposable {
       if (ctx !== this.ctx.value)
         throw new Error("QuickJSContext instance received C -> JS call with mismatched ctx");
       let fn = this.getFunction(fn_id);
-      return Scope.withScopeMaybeAsync(this, function* (awaited, scope) {
-        let thisHandle = scope.manage(new WeakLifetime(this_ptr, this.memory.copyJSValue, this.memory.freeJSValue, this.runtime)), argHandles = new Array(argc);
+      return Scope2.withScopeMaybeAsync(this, function* (awaited, scope) {
+        let thisHandle = scope.manage(new WeakLifetime2(this_ptr, this.memory.copyJSValue, this.memory.freeJSValue, this.runtime)), argHandles = new Array(argc);
         for (let i = 0;i < argc; i++) {
           let ptr = this.ffi.QTS_ArgvGetJSValueConstPointer(argv, i);
-          argHandles[i] = scope.manage(new WeakLifetime(ptr, this.memory.copyJSValue, this.memory.freeJSValue, this.runtime));
+          argHandles[i] = scope.manage(new WeakLifetime2(ptr, this.memory.copyJSValue, this.memory.freeJSValue, this.runtime));
         }
         try {
           let result = yield* awaited(fn.apply(thisHandle, argHandles));
           if (result) {
             if ("error" in result && result.error)
               throw this.runtime.debugLog("throw error", result.error), result.error;
-            let handle = scope.manage(result instanceof Lifetime ? result : result.value);
+            let handle = scope.manage(result instanceof Lifetime2 ? result : result.value);
             return this.ffi.QTS_DupValuePointer(this.ctx.value, handle.value);
           }
           return 0;
@@ -602,25 +612,25 @@ var QuickJSContext = class extends UsingDisposable {
     if (this._undefined)
       return this._undefined;
     let ptr = this.ffi.QTS_GetUndefined();
-    return this._undefined = new StaticLifetime(ptr);
+    return this._undefined = new StaticLifetime2(ptr);
   }
   get null() {
     if (this._null)
       return this._null;
     let ptr = this.ffi.QTS_GetNull();
-    return this._null = new StaticLifetime(ptr);
+    return this._null = new StaticLifetime2(ptr);
   }
   get true() {
     if (this._true)
       return this._true;
     let ptr = this.ffi.QTS_GetTrue();
-    return this._true = new StaticLifetime(ptr);
+    return this._true = new StaticLifetime2(ptr);
   }
   get false() {
     if (this._false)
       return this._false;
     let ptr = this.ffi.QTS_GetFalse();
-    return this._false = new StaticLifetime(ptr);
+    return this._false = new StaticLifetime2(ptr);
   }
   get global() {
     if (this._global)
@@ -649,7 +659,7 @@ var QuickJSContext = class extends UsingDisposable {
   newBigInt(num) {
     if (!this._BigInt) {
       let bigIntHandle2 = this.getProp(this.global, "BigInt");
-      this.memory.manage(bigIntHandle2), this._BigInt = new StaticLifetime(bigIntHandle2.value, this.runtime);
+      this.memory.manage(bigIntHandle2), this._BigInt = new StaticLifetime2(bigIntHandle2.value, this.runtime);
     }
     let bigIntHandle = this._BigInt, asString = String(num);
     return this.newString(asString).consume((handle) => this.unwrapResult(this.callFunction(bigIntHandle, this.undefined, handle)));
@@ -668,11 +678,11 @@ var QuickJSContext = class extends UsingDisposable {
     return this.memory.heapValueHandle(ptr);
   }
   newPromise(value) {
-    let deferredPromise = Scope.withScope((scope) => {
+    let deferredPromise = Scope2.withScope((scope) => {
       let mutablePointerArray = scope.manage(this.memory.newMutablePointerArray(2)), promisePtr = this.ffi.QTS_NewPromiseCapability(this.ctx.value, mutablePointerArray.value.ptr), promiseHandle = this.memory.heapValueHandle(promisePtr), [resolveHandle, rejectHandle] = Array.from(mutablePointerArray.value.typedArray).map((jsvaluePtr) => this.memory.heapValueHandle(jsvaluePtr));
-      return new QuickJSDeferredPromise({ context: this, promiseHandle, resolveHandle, rejectHandle });
+      return new QuickJSDeferredPromise2({ context: this, promiseHandle, resolveHandle, rejectHandle });
     });
-    return value && typeof value == "function" && (value = new Promise(value)), value && Promise.resolve(value).then(deferredPromise.resolve, (error) => error instanceof Lifetime ? deferredPromise.reject(error) : this.newError(error).consume(deferredPromise.reject)), deferredPromise;
+    return value && typeof value == "function" && (value = new Promise(value)), value && Promise.resolve(value).then(deferredPromise.resolve, (error) => error instanceof Lifetime2 ? deferredPromise.reject(error) : this.newError(error).consume(deferredPromise.reject)), deferredPromise;
   }
   newFunction(nameOrFn, maybeFn) {
     let fn = typeof nameOrFn == "function" ? nameOrFn : maybeFn;
@@ -742,32 +752,32 @@ var QuickJSContext = class extends UsingDisposable {
     let len = this.ffi.QTS_GetArrayBufferLength(this.ctx.value, handle.value), ptr = this.ffi.QTS_GetArrayBuffer(this.ctx.value, handle.value);
     if (!ptr)
       throw new Error("Couldn't allocate memory to get ArrayBuffer");
-    return new Lifetime(this.module.HEAPU8.subarray(ptr, ptr + len), undefined, () => this.module._free(ptr));
+    return new Lifetime2(this.module.HEAPU8.subarray(ptr, ptr + len), undefined, () => this.module._free(ptr));
   }
   getPromiseState(handle) {
     this.runtime.assertOwned(handle);
     let state = this.ffi.QTS_PromiseState(this.ctx.value, handle.value);
     if (state < 0)
       return { type: "fulfilled", value: handle, notAPromise: true };
-    if (state === JSPromiseStateEnum.Pending)
+    if (state === JSPromiseStateEnum2.Pending)
       return { type: "pending", get error() {
         return new QuickJSPromisePending("Cannot unwrap a pending promise");
       } };
     let ptr = this.ffi.QTS_PromiseResult(this.ctx.value, handle.value), result = this.memory.heapValueHandle(ptr);
-    if (state === JSPromiseStateEnum.Fulfilled)
+    if (state === JSPromiseStateEnum2.Fulfilled)
       return { type: "fulfilled", value: result };
-    if (state === JSPromiseStateEnum.Rejected)
+    if (state === JSPromiseStateEnum2.Rejected)
       return { type: "rejected", error: result };
     throw result.dispose(), new Error(`Unknown JSPromiseStateEnum: ${state}`);
   }
   resolvePromise(promiseLikeHandle) {
     this.runtime.assertOwned(promiseLikeHandle);
-    let vmResolveResult = Scope.withScope((scope) => {
+    let vmResolveResult = Scope2.withScope((scope) => {
       let vmPromise = scope.manage(this.getProp(this.global, "Promise")), vmPromiseResolve = scope.manage(this.getProp(vmPromise, "resolve"));
       return this.callFunction(vmPromiseResolve, vmPromise, promiseLikeHandle);
     });
     return vmResolveResult.error ? Promise.resolve(vmResolveResult) : new Promise((resolve) => {
-      Scope.withScope((scope) => {
+      Scope2.withScope((scope) => {
         let resolveHandle = scope.manage(this.newFunction("resolve", (value) => {
           resolve(this.success(value && value.dup()));
         })), rejectHandle = scope.manage(this.newFunction("reject", (error) => {
@@ -777,7 +787,7 @@ var QuickJSContext = class extends UsingDisposable {
       });
     });
   }
-  isEqual(a, b, equalityType = IsEqualOp.IsStrictlyEqual) {
+  isEqual(a, b, equalityType = IsEqualOp2.IsStrictlyEqual) {
     if (a === b)
       return true;
     this.runtime.assertOwned(a), this.runtime.assertOwned(b);
@@ -787,13 +797,13 @@ var QuickJSContext = class extends UsingDisposable {
     return !!result;
   }
   eq(handle, other) {
-    return this.isEqual(handle, other, IsEqualOp.IsStrictlyEqual);
+    return this.isEqual(handle, other, IsEqualOp2.IsStrictlyEqual);
   }
   sameValue(handle, other) {
-    return this.isEqual(handle, other, IsEqualOp.IsSameValue);
+    return this.isEqual(handle, other, IsEqualOp2.IsSameValue);
   }
   sameValueZero(handle, other) {
-    return this.isEqual(handle, other, IsEqualOp.IsSameValueZero);
+    return this.isEqual(handle, other, IsEqualOp2.IsSameValueZero);
   }
   getProp(handle, key) {
     this.runtime.assertOwned(handle);
@@ -809,17 +819,17 @@ var QuickJSContext = class extends UsingDisposable {
     let flags = getOwnPropertyNamesOptionsToFlags(options);
     if (flags === 0)
       throw new QuickJSEmptyGetOwnPropertyNames("No options set, will return an empty array");
-    return Scope.withScope((scope) => {
+    return Scope2.withScope((scope) => {
       let outPtr = scope.manage(this.memory.newMutablePointerArray(1)), errorPtr = this.ffi.QTS_GetOwnPropertyNames(this.ctx.value, outPtr.value.ptr, this.uint32Out.value.ptr, handle.value, flags);
       if (errorPtr)
         return this.fail(this.memory.heapValueHandle(errorPtr));
       let len = this.uint32Out.value.typedArray[0], ptr = outPtr.value.typedArray[0], pointerArray = new Uint32Array(this.module.HEAP8.buffer, ptr, len), handles = Array.from(pointerArray).map((ptr2) => this.memory.heapValueHandle(ptr2));
-      return this.ffi.QTS_FreeVoidPointer(this.ctx.value, ptr), this.success(createDisposableArray(handles));
+      return this.ffi.QTS_FreeVoidPointer(this.ctx.value, ptr), this.success(createDisposableArray2(handles));
     });
   }
   getIterator(iterableHandle) {
     let SymbolIterator = this._SymbolIterator ?? (this._SymbolIterator = this.memory.manage(this.getWellKnownSymbol("iterator")));
-    return Scope.withScope((scope) => {
+    return Scope2.withScope((scope) => {
       let methodHandle = scope.manage(this.getProp(iterableHandle, SymbolIterator)), iteratorCallResult = this.callFunction(methodHandle, iterableHandle);
       return iteratorCallResult.error ? iteratorCallResult : this.success(new QuickJSIterator(iteratorCallResult.value, this));
     });
@@ -828,7 +838,7 @@ var QuickJSContext = class extends UsingDisposable {
     this.runtime.assertOwned(handle), this.borrowPropertyKey(key).consume((quickJSKey) => this.ffi.QTS_SetProp(this.ctx.value, handle.value, quickJSKey.value, value.value));
   }
   defineProp(handle, key, descriptor) {
-    this.runtime.assertOwned(handle), Scope.withScope((scope) => {
+    this.runtime.assertOwned(handle), Scope2.withScope((scope) => {
       let quickJSKey = scope.manage(this.borrowPropertyKey(key)), value = descriptor.value || this.undefined, configurable = !!descriptor.configurable, enumerable = !!descriptor.enumerable, hasValue = !!descriptor.value, get = descriptor.get ? scope.manage(this.newFunction(descriptor.get.name, descriptor.get)) : this.undefined, set = descriptor.set ? scope.manage(this.newFunction(descriptor.set.name, descriptor.set)) : this.undefined;
       this.ffi.QTS_DefineProp(this.ctx.value, handle.value, quickJSKey.value, value.value, get.value, set.value, configurable, enumerable, hasValue);
     });
@@ -851,7 +861,7 @@ var QuickJSContext = class extends UsingDisposable {
     return this.errorToHandle(error).consume((handle) => this.ffi.QTS_Throw(this.ctx.value, handle.value));
   }
   borrowPropertyKey(key) {
-    return typeof key == "number" ? this.newNumber(key) : typeof key == "string" ? this.newString(key) : new StaticLifetime(key.value, this.runtime);
+    return typeof key == "number" ? this.newNumber(key) : typeof key == "string" ? this.newString(key) : new StaticLifetime2(key.value, this.runtime);
   }
   getMemory(rt) {
     if (rt === this.rt.value)
@@ -909,7 +919,7 @@ ${cause.stack}Host: ${hostStack}`), Object.assign(exception, rest), exception;
     return fn;
   }
   errorToHandle(error) {
-    return error instanceof Lifetime ? error : this.newError(error);
+    return error instanceof Lifetime2 ? error : this.newError(error);
   }
   encodeBinaryJSON(handle) {
     let ptr = this.ffi.QTS_bjson_encode(this.ctx.value, handle.value);
@@ -920,16 +930,16 @@ ${cause.stack}Host: ${hostStack}`), Object.assign(exception, rest), exception;
     return this.memory.heapValueHandle(ptr);
   }
   success(value) {
-    return DisposableResult.success(value);
+    return DisposableResult2.success(value);
   }
   fail(error) {
-    return DisposableResult.fail(error, (error2) => this.unwrapResult(error2));
+    return DisposableResult2.fail(error, (error2) => this.unwrapResult(error2));
   }
 };
-var QuickJSRuntime = class extends UsingDisposable {
+var QuickJSRuntime2 = class extends UsingDisposable2 {
   constructor(args) {
     super();
-    this.scope = new Scope;
+    this.scope = new Scope2;
     this.contextMap = new Map;
     this.hostRefs = new HostRefMap;
     this._debugMode = false;
@@ -986,9 +996,9 @@ var QuickJSRuntime = class extends UsingDisposable {
     return this.scope.dispose();
   }
   newContext(options = {}) {
-    let intrinsics = intrinsicsToFlags(options.intrinsics), ctx = new Lifetime(options.contextPointer || this.ffi.QTS_NewContext(this.rt.value, intrinsics), undefined, (ctx_ptr) => {
+    let intrinsics = intrinsicsToFlags(options.intrinsics), ctx = new Lifetime2(options.contextPointer || this.ffi.QTS_NewContext(this.rt.value, intrinsics), undefined, (ctx_ptr) => {
       this.contextMap.delete(ctx_ptr), this.callbacks.deleteContext(ctx_ptr), this.ffi.QTS_FreeContext(ctx_ptr);
-    }), context = new QuickJSContext({ module: this.module, ctx, ffi: this.ffi, rt: this.rt, ownedLifetimes: options.ownedLifetimes, runtime: this, callbacks: this.callbacks });
+    }), context = new QuickJSContext2({ module: this.module, ctx, ffi: this.ffi, rt: this.rt, ownedLifetimes: options.ownedLifetimes, runtime: this, callbacks: this.callbacks });
     return this.contextMap.set(ctx.value, context), context;
   }
   setModuleLoader(moduleLoader, moduleNormalizer) {
@@ -1010,14 +1020,14 @@ var QuickJSRuntime = class extends UsingDisposable {
   executePendingJobs(maxJobsToExecute = -1) {
     let ctxPtrOut = this.memory.newMutablePointerArray(1), valuePtr = this.ffi.QTS_ExecutePendingJob(this.rt.value, maxJobsToExecute ?? -1, ctxPtrOut.value.ptr), ctxPtr = ctxPtrOut.value.typedArray[0];
     if (ctxPtrOut.dispose(), ctxPtr === 0)
-      return this.ffi.QTS_FreeValuePointerRuntime(this.rt.value, valuePtr), DisposableResult.success(0);
+      return this.ffi.QTS_FreeValuePointerRuntime(this.rt.value, valuePtr), DisposableResult2.success(0);
     let context = this.contextMap.get(ctxPtr) ?? this.newContext({ contextPointer: ctxPtr }), resultValue = context.getMemory(this.rt.value).heapValueHandle(valuePtr);
     if (context.typeof(resultValue) === "number") {
       let executedJobs = context.getNumber(resultValue);
-      return resultValue.dispose(), DisposableResult.success(executedJobs);
+      return resultValue.dispose(), DisposableResult2.success(executedJobs);
     } else {
       let error = Object.assign(resultValue, { context });
-      return DisposableResult.fail(error, (error2) => context.unwrapResult(error2));
+      return DisposableResult2.fail(error, (error2) => context.unwrapResult(error2));
     }
   }
   setMemoryLimit(limitBytes) {
@@ -1062,7 +1072,7 @@ var QuickJSEmscriptenModuleCallbacks = class {
     this.freeHostRef = args.freeHostRef, this.callFunction = args.callFunction, this.shouldInterrupt = args.shouldInterrupt, this.loadModuleSource = args.loadModuleSource, this.normalizeModule = args.normalizeModule;
   }
 };
-var QuickJSModuleCallbacks = class {
+var QuickJSModuleCallbacks2 = class {
   constructor(module) {
     this.contextCallbacks = new Map;
     this.runtimeCallbacks = new Map;
@@ -1135,19 +1145,19 @@ var QuickJSModuleCallbacks = class {
         try {
           let result = fn();
           if (!(result instanceof Promise)) {
-            debugLog("asyncify.handleSleep: not suspending:", result), done(result);
+            debugLog2("asyncify.handleSleep: not suspending:", result), done(result);
             return;
           }
           if (this.suspended)
             throw new QuickJSAsyncifyError(`Already suspended at: ${this.suspended.stack}
 Attempted to suspend at:`);
-          this.suspended = new QuickJSAsyncifySuspended(`(${this.suspendedCount++})`), debugLog("asyncify.handleSleep: suspending:", this.suspended), result.then((resolvedResult) => {
-            this.suspended = undefined, debugLog("asyncify.handleSleep: resolved:", resolvedResult), done(resolvedResult);
+          this.suspended = new QuickJSAsyncifySuspended(`(${this.suspendedCount++})`), debugLog2("asyncify.handleSleep: suspending:", this.suspended), result.then((resolvedResult) => {
+            this.suspended = undefined, debugLog2("asyncify.handleSleep: resolved:", resolvedResult), done(resolvedResult);
           }, (error) => {
-            debugLog("asyncify.handleSleep: rejected:", error), console.error("QuickJS: cannot handle error in suspended function", error), this.suspended = undefined;
+            debugLog2("asyncify.handleSleep: rejected:", error), console.error("QuickJS: cannot handle error in suspended function", error), this.suspended = undefined;
           });
         } catch (error) {
-          throw debugLog("asyncify.handleSleep: error:", error), this.suspended = undefined, error;
+          throw debugLog2("asyncify.handleSleep: error:", error), this.suspended = undefined, error;
         }
       });
     let value = fn();
@@ -1156,30 +1166,30 @@ Attempted to suspend at:`);
     return value;
   }
 };
-function applyBaseRuntimeOptions(runtime, options) {
+function applyBaseRuntimeOptions2(runtime, options) {
   options.interruptHandler && runtime.setInterruptHandler(options.interruptHandler), options.maxStackSizeBytes !== undefined && runtime.setMaxStackSize(options.maxStackSizeBytes), options.memoryLimitBytes !== undefined && runtime.setMemoryLimit(options.memoryLimitBytes);
 }
-function applyModuleEvalRuntimeOptions(runtime, options) {
+function applyModuleEvalRuntimeOptions2(runtime, options) {
   options.moduleLoader && runtime.setModuleLoader(options.moduleLoader), options.shouldInterrupt && runtime.setInterruptHandler(options.shouldInterrupt), options.memoryLimitBytes !== undefined && runtime.setMemoryLimit(options.memoryLimitBytes), options.maxStackSizeBytes !== undefined && runtime.setMaxStackSize(options.maxStackSizeBytes);
 }
-var QuickJSWASMModule = class {
+var QuickJSWASMModule2 = class {
   constructor(module, ffi) {
-    this.module = module, this.ffi = ffi, this.callbacks = new QuickJSModuleCallbacks(module);
+    this.module = module, this.ffi = ffi, this.callbacks = new QuickJSModuleCallbacks2(module);
   }
   newRuntime(options = {}) {
-    let rt = new Lifetime(this.ffi.QTS_NewRuntime(), undefined, (rt_ptr) => {
+    let rt = new Lifetime2(this.ffi.QTS_NewRuntime(), undefined, (rt_ptr) => {
       this.ffi.QTS_FreeRuntime(rt_ptr), this.callbacks.deleteRuntime(rt_ptr);
-    }), runtime = new QuickJSRuntime({ module: this.module, callbacks: this.callbacks, ffi: this.ffi, rt });
-    return applyBaseRuntimeOptions(runtime, options), options.moduleLoader && runtime.setModuleLoader(options.moduleLoader), runtime;
+    }), runtime = new QuickJSRuntime2({ module: this.module, callbacks: this.callbacks, ffi: this.ffi, rt });
+    return applyBaseRuntimeOptions2(runtime, options), options.moduleLoader && runtime.setModuleLoader(options.moduleLoader), runtime;
   }
   newContext(options = {}) {
     let runtime = this.newRuntime(), context = runtime.newContext({ ...options, ownedLifetimes: concat(runtime, options.ownedLifetimes) });
     return runtime.context = context, context;
   }
   evalCode(code, options = {}) {
-    return Scope.withScope((scope) => {
+    return Scope2.withScope((scope) => {
       let vm = scope.manage(this.newContext());
-      applyModuleEvalRuntimeOptions(vm.runtime, options);
+      applyModuleEvalRuntimeOptions2(vm.runtime, options);
       let result = vm.evalCode(code, "eval.js");
       if (options.memoryLimitBytes !== undefined && vm.runtime.setMemoryLimit(-1), result.error)
         throw vm.dump(scope.manage(result.error));
@@ -1198,7 +1208,7 @@ var QuickJSWASMModule = class {
 };
 
 // ../../node_modules/.bun/quickjs-emscripten-core@0.32.0/node_modules/quickjs-emscripten-core/dist/chunk-TAV5CUKK.mjs
-var QuickJSAsyncContext = class extends QuickJSContext {
+var QuickJSAsyncContext2 = class extends QuickJSContext2 {
   async evalCodeAsync(code, filename = "eval.js", options) {
     let detectModule = options === undefined ? 1 : 0, flags = evalOptionsToFlags(options), resultPtr = 0;
     try {
@@ -1213,14 +1223,14 @@ var QuickJSAsyncContext = class extends QuickJSContext {
     return this.newFunction(name, fn);
   }
 };
-var QuickJSAsyncRuntime = class extends QuickJSRuntime {
+var QuickJSAsyncRuntime2 = class extends QuickJSRuntime2 {
   constructor(args) {
     super(args);
   }
   newContext(options = {}) {
-    let intrinsics = intrinsicsToFlags(options.intrinsics), ctx = new Lifetime(this.ffi.QTS_NewContext(this.rt.value, intrinsics), undefined, (ctx_ptr) => {
+    let intrinsics = intrinsicsToFlags(options.intrinsics), ctx = new Lifetime2(this.ffi.QTS_NewContext(this.rt.value, intrinsics), undefined, (ctx_ptr) => {
       this.contextMap.delete(ctx_ptr), this.callbacks.deleteContext(ctx_ptr), this.ffi.QTS_FreeContext(ctx_ptr);
-    }), context = new QuickJSAsyncContext({ module: this.module, ctx, ffi: this.ffi, rt: this.rt, ownedLifetimes: [], runtime: this, callbacks: this.callbacks });
+    }), context = new QuickJSAsyncContext2({ module: this.module, ctx, ffi: this.ffi, rt: this.rt, ownedLifetimes: [], runtime: this, callbacks: this.callbacks });
     return this.contextMap.set(ctx.value, context), context;
   }
   setModuleLoader(moduleLoader, moduleNormalizer) {
@@ -1230,16 +1240,16 @@ var QuickJSAsyncRuntime = class extends QuickJSRuntime {
     return super.setMaxStackSize(stackSize);
   }
 };
-var QuickJSAsyncWASMModule = class extends QuickJSWASMModule {
+var QuickJSAsyncWASMModule2 = class extends QuickJSWASMModule2 {
   constructor(module, ffi) {
     super(module, ffi);
     this.ffi = ffi, this.module = module;
   }
   newRuntime(options = {}) {
-    let rt = new Lifetime(this.ffi.QTS_NewRuntime(), undefined, (rt_ptr) => {
+    let rt = new Lifetime2(this.ffi.QTS_NewRuntime(), undefined, (rt_ptr) => {
       this.callbacks.deleteRuntime(rt_ptr), this.ffi.QTS_FreeRuntime(rt_ptr);
-    }), runtime = new QuickJSAsyncRuntime({ module: this.module, ffi: this.ffi, rt, callbacks: this.callbacks });
-    return applyBaseRuntimeOptions(runtime, options), options.moduleLoader && runtime.setModuleLoader(options.moduleLoader), runtime;
+    }), runtime = new QuickJSAsyncRuntime2({ module: this.module, ffi: this.ffi, rt, callbacks: this.callbacks });
+    return applyBaseRuntimeOptions2(runtime, options), options.moduleLoader && runtime.setModuleLoader(options.moduleLoader), runtime;
   }
   newContext(options = {}) {
     let runtime = this.newRuntime(), lifetimes = options.ownedLifetimes ? options.ownedLifetimes.concat([runtime]) : [runtime], context = runtime.newContext({ ...options, ownedLifetimes: lifetimes });
@@ -1249,9 +1259,9 @@ var QuickJSAsyncWASMModule = class extends QuickJSWASMModule {
     throw new QuickJSNotImplemented("QuickJSWASMModuleAsyncify.evalCode: use evalCodeAsync instead");
   }
   evalCodeAsync(code, options) {
-    return Scope.withScopeAsync(async (scope) => {
+    return Scope2.withScopeAsync(async (scope) => {
       let vm = scope.manage(this.newContext());
-      applyModuleEvalRuntimeOptions(vm.runtime, options);
+      applyModuleEvalRuntimeOptions2(vm.runtime, options);
       let result = await vm.evalCodeAsync(code, "eval.js");
       if (options.memoryLimitBytes !== undefined && vm.runtime.setMemoryLimit(-1), result.error)
         throw vm.dump(scope.manage(result.error));
@@ -1259,6 +1269,5 @@ var QuickJSAsyncWASMModule = class extends QuickJSWASMModule {
     });
   }
 };
-export {
-  QuickJSAsyncWASMModule
-};
+
+export { assertSync2, EvalFlags2, IntrinsicsFlags2, JSPromiseStateEnum2, GetOwnPropertyNamesFlags2, IsEqualOp2, setDebugMode2, debugLog2, errors_exports, QuickJSMemoryLeakDetected, QuickJSEmscriptenModuleError, UsingDisposable2, Lifetime2, StaticLifetime2, WeakLifetime2, Scope2, createDisposableArray2, DisposableSuccess2, DisposableFail2, DisposableResult2, QuickJSDeferredPromise2, DefaultIntrinsics2, QuickJSContext2, QuickJSRuntime2, QuickJSModuleCallbacks2, applyBaseRuntimeOptions2, applyModuleEvalRuntimeOptions2, QuickJSWASMModule2, QuickJSAsyncContext2, QuickJSAsyncRuntime2, QuickJSAsyncWASMModule2 };