@fluffylabs/anan-as 1.0.0-031e728

package/build/debug.d.ts

@@ -0,0 +1,204 @@
+/** Exported memory */
+export declare const memory: WebAssembly.Memory;
+/**
+ * assembly/api-internal/getAssembly
+ * @param p `assembly/program/Program`
+ * @returns `~lib/string/String`
+ */
+export declare function getAssembly(p: __Internref26): string;
+/**
+ * assembly/program-build/wrapAsProgram
+ * @param bytecode `~lib/typedarray/Uint8Array`
+ * @returns `~lib/typedarray/Uint8Array`
+ */
+export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array;
+/**
+ * assembly/api-debugger/resetJAM
+ * @param program `~lib/array/Array<u8>`
+ * @param pc `f64`
+ * @param initialGas `i64`
+ * @param args `~lib/array/Array<u8>`
+ * @param hasMetadata `bool`
+ */
+export declare function resetJAM(program: Array<number>, pc: number, initialGas: bigint, args: Array<number>, hasMetadata?: boolean): void;
+/**
+ * assembly/api-debugger/resetGeneric
+ * @param program `~lib/array/Array<u8>`
+ * @param flatRegisters `~lib/array/Array<u8>`
+ * @param initialGas `i64`
+ * @param hasMetadata `bool`
+ */
+export declare function resetGeneric(program: Array<number>, flatRegisters: Array<number>, initialGas: bigint, hasMetadata?: boolean): void;
+/**
+ * assembly/api-debugger/resetGenericWithMemory
+ * @param program `~lib/array/Array<u8>`
+ * @param flatRegisters `~lib/array/Array<u8>`
+ * @param pageMap `~lib/typedarray/Uint8Array`
+ * @param chunks `~lib/typedarray/Uint8Array`
+ * @param initialGas `i64`
+ * @param hasMetadata `bool`
+ */
+export declare function resetGenericWithMemory(program: Array<number>, flatRegisters: Array<number>, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint, hasMetadata?: boolean): void;
+/**
+ * assembly/api-debugger/nextStep
+ * @returns `bool`
+ */
+export declare function nextStep(): boolean;
+/**
+ * assembly/api-debugger/nSteps
+ * @param steps `u32`
+ * @returns `bool`
+ */
+export declare function nSteps(steps: number): boolean;
+/**
+ * assembly/api-debugger/getProgramCounter
+ * @returns `u32`
+ */
+export declare function getProgramCounter(): number;
+/**
+ * assembly/api-debugger/setNextProgramCounter
+ * @param pc `u32`
+ */
+export declare function setNextProgramCounter(pc: number): void;
+/**
+ * assembly/api-debugger/getStatus
+ * @returns `u8`
+ */
+export declare function getStatus(): number;
+/**
+ * assembly/api-debugger/getExitArg
+ * @returns `u32`
+ */
+export declare function getExitArg(): number;
+/**
+ * assembly/api-debugger/getGasLeft
+ * @returns `i64`
+ */
+export declare function getGasLeft(): bigint;
+/**
+ * assembly/api-debugger/setGasLeft
+ * @param gas `i64`
+ */
+export declare function setGasLeft(gas: bigint): void;
+/**
+ * assembly/api-debugger/getRegisters
+ * @returns `~lib/typedarray/Uint8Array`
+ */
+export declare function getRegisters(): Uint8Array;
+/**
+ * assembly/api-debugger/setRegisters
+ * @param flatRegisters `~lib/array/Array<u8>`
+ */
+export declare function setRegisters(flatRegisters: Array<number>): void;
+/**
+ * assembly/api-debugger/getPageDump
+ * @param index `u32`
+ * @returns `~lib/typedarray/Uint8Array`
+ */
+export declare function getPageDump(index: number): Uint8Array;
+/**
+ * assembly/api-debugger/setMemory
+ * @param address `u32`
+ * @param data `~lib/typedarray/Uint8Array`
+ */
+export declare function setMemory(address: number, data: Uint8Array): void;
+/** assembly/api-utils/InputKind */
+export declare enum InputKind {
+  /** @type `i32` */
+  Generic,
+  /** @type `i32` */
+  SPI,
+}
+/** assembly/api-utils/HasMetadata */
+export declare enum HasMetadata {
+  /** @type `i32` */
+  Yes,
+  /** @type `i32` */
+  No,
+}
+/**
+ * assembly/api-utils/getGasCosts
+ * @param input `~lib/array/Array<u8>`
+ * @param kind `i32`
+ * @param withMetadata `i32`
+ * @returns `~lib/array/Array<assembly/gas-costs/BlockGasCost>`
+ */
+export declare function getGasCosts(input: Array<number>, kind: number, withMetadata: number): Array<__Record50<never>>;
+/**
+ * assembly/api-utils/disassemble
+ * @param input `~lib/array/Array<u8>`
+ * @param kind `i32`
+ * @param withMetadata `i32`
+ * @returns `~lib/string/String`
+ */
+export declare function disassemble(input: Array<number>, kind: number, withMetadata: number): string;
+/**
+ * assembly/api-utils/prepareProgram
+ * @param kind `i32`
+ * @param hasMetadata `i32`
+ * @param program `~lib/array/Array<u8>`
+ * @param initialRegisters `~lib/array/Array<u64>`
+ * @param initialPageMap `~lib/array/Array<assembly/api-internal/InitialPage>`
+ * @param initialMemory `~lib/array/Array<assembly/api-internal/InitialChunk>`
+ * @param args `~lib/array/Array<u8>`
+ * @returns `assembly/spi/StandardProgram`
+ */
+export declare function prepareProgram(kind: number, hasMetadata: number, program: Array<number>, initialRegisters: Array<bigint>, initialPageMap: Array<__Record46<undefined>>, initialMemory: Array<__Record48<undefined>>, args: Array<number>): __Internref42;
+/**
+ * assembly/api-utils/runProgram
+ * @param program `assembly/spi/StandardProgram`
+ * @param initialGas `i64`
+ * @param programCounter `u32`
+ * @param logs `bool`
+ * @param useSbrkGas `bool`
+ * @returns `assembly/api-internal/VmOutput`
+ */
+export declare function runProgram(program: __Internref42, initialGas?: bigint, programCounter?: number, logs?: boolean, useSbrkGas?: boolean): __Record55<never>;
+/** assembly/program/Program */
+declare class __Internref26 extends Number {
+  private __nominal26: symbol;
+  private __nominal0: symbol;
+}
+/** assembly/gas-costs/BlockGasCost */
+declare interface __Record50<TOmittable> {
+  /** @type `u32` */
+  pc: number | TOmittable;
+  /** @type `u64` */
+  gas: bigint | TOmittable;
+}
+/** assembly/api-internal/InitialPage */
+declare interface __Record46<TOmittable> {
+  /** @type `u32` */
+  address: number | TOmittable;
+  /** @type `u32` */
+  length: number | TOmittable;
+  /** @type `i32` */
+  access: number | TOmittable;
+}
+/** assembly/api-internal/InitialChunk */
+declare interface __Record48<TOmittable> {
+  /** @type `u32` */
+  address: number | TOmittable;
+  /** @type `~lib/array/Array<u8>` */
+  data: Array<number>;
+}
+/** assembly/spi/StandardProgram */
+declare class __Internref42 extends Number {
+  private __nominal42: symbol;
+  private __nominal0: symbol;
+}
+/** assembly/api-internal/VmOutput */
+declare interface __Record55<TOmittable> {
+  /** @type `i32` */
+  status: number | TOmittable;
+  /** @type `~lib/array/Array<u64>` */
+  registers: Array<bigint>;
+  /** @type `u32` */
+  pc: number | TOmittable;
+  /** @type `~lib/array/Array<assembly/api-internal/InitialChunk>` */
+  memory: Array<__Record48<never>>;
+  /** @type `i64` */
+  gas: bigint | TOmittable;
+  /** @type `u32` */
+  exitCode: number | TOmittable;
+}

package/build/debug.js

@@ -0,0 +1,405 @@
+async function instantiate(module, imports = {}) {
+  const adaptedImports = {
+    env: Object.setPrototypeOf({
+      abort(message, fileName, lineNumber, columnNumber) {
+        // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void
+        message = __liftString(message >>> 0);
+        fileName = __liftString(fileName >>> 0);
+        lineNumber = lineNumber >>> 0;
+        columnNumber = columnNumber >>> 0;
+        (() => {
+          // @external.js
+          throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);
+        })();
+      },
+      "console.log"(text) {
+        // ~lib/bindings/dom/console.log(~lib/string/String) => void
+        text = __liftString(text >>> 0);
+        console.log(text);
+      },
+    }, Object.assign(Object.create(globalThis), imports.env || {})),
+  };
+  const { exports } = await WebAssembly.instantiate(module, adaptedImports);
+  const memory = exports.memory || imports.env.memory;
+  const adaptedExports = Object.setPrototypeOf({
+    getAssembly(p) {
+      // assembly/api-internal/getAssembly(assembly/program/Program) => ~lib/string/String
+      p = __lowerInternref(p) || __notnull();
+      return __liftString(exports.getAssembly(p) >>> 0);
+    },
+    wrapAsProgram(bytecode) {
+      // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array
+      bytecode = __lowerTypedArray(Uint8Array, 10, 0, bytecode) || __notnull();
+      return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0);
+    },
+    resetJAM(program, pc, initialGas, args, hasMetadata) {
+      // assembly/api-debugger/resetJAM(~lib/array/Array<u8>, f64, i64, ~lib/array/Array<u8>, bool?) => void
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      initialGas = initialGas || 0n;
+      args = __lowerArray(__setU8, 6, 0, args) || __notnull();
+      hasMetadata = hasMetadata ? 1 : 0;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        exports.resetJAM(program, pc, initialGas, args, hasMetadata);
+      } finally {
+        __release(program);
+      }
+    },
+    resetGeneric(program, flatRegisters, initialGas, hasMetadata) {
+      // assembly/api-debugger/resetGeneric(~lib/array/Array<u8>, ~lib/array/Array<u8>, i64, bool?) => void
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      flatRegisters = __lowerArray(__setU8, 6, 0, flatRegisters) || __notnull();
+      initialGas = initialGas || 0n;
+      hasMetadata = hasMetadata ? 1 : 0;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        exports.resetGeneric(program, flatRegisters, initialGas, hasMetadata);
+      } finally {
+        __release(program);
+      }
+    },
+    resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata) {
+      // assembly/api-debugger/resetGenericWithMemory(~lib/array/Array<u8>, ~lib/array/Array<u8>, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64, bool?) => void
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      flatRegisters = __retain(__lowerArray(__setU8, 6, 0, flatRegisters) || __notnull());
+      pageMap = __retain(__lowerTypedArray(Uint8Array, 10, 0, pageMap) || __notnull());
+      chunks = __lowerTypedArray(Uint8Array, 10, 0, chunks) || __notnull();
+      initialGas = initialGas || 0n;
+      hasMetadata = hasMetadata ? 1 : 0;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata);
+      } finally {
+        __release(program);
+        __release(flatRegisters);
+        __release(pageMap);
+      }
+    },
+    nextStep() {
+      // assembly/api-debugger/nextStep() => bool
+      return exports.nextStep() != 0;
+    },
+    nSteps(steps) {
+      // assembly/api-debugger/nSteps(u32) => bool
+      return exports.nSteps(steps) != 0;
+    },
+    getProgramCounter() {
+      // assembly/api-debugger/getProgramCounter() => u32
+      return exports.getProgramCounter() >>> 0;
+    },
+    getExitArg() {
+      // assembly/api-debugger/getExitArg() => u32
+      return exports.getExitArg() >>> 0;
+    },
+    setGasLeft(gas) {
+      // assembly/api-debugger/setGasLeft(i64) => void
+      gas = gas || 0n;
+      exports.setGasLeft(gas);
+    },
+    getRegisters() {
+      // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array
+      return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0);
+    },
+    setRegisters(flatRegisters) {
+      // assembly/api-debugger/setRegisters(~lib/array/Array<u8>) => void
+      flatRegisters = __lowerArray(__setU8, 6, 0, flatRegisters) || __notnull();
+      exports.setRegisters(flatRegisters);
+    },
+    getPageDump(index) {
+      // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array
+      return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0);
+    },
+    setMemory(address, data) {
+      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void
+      data = __lowerTypedArray(Uint8Array, 10, 0, data) || __notnull();
+      exports.setMemory(address, data);
+    },
+    InputKind: (values => (
+      // assembly/api-utils/InputKind
+      values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic",
+      values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI",
+      values
+    ))({}),
+    HasMetadata: (values => (
+      // assembly/api-utils/HasMetadata
+      values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes",
+      values[values.No = exports["HasMetadata.No"].valueOf()] = "No",
+      values
+    ))({}),
+    getGasCosts(input, kind, withMetadata) {
+      // assembly/api-utils/getGasCosts(~lib/array/Array<u8>, i32, i32) => ~lib/array/Array<assembly/gas-costs/BlockGasCost>
+      input = __lowerArray(__setU8, 6, 0, input) || __notnull();
+      return __liftArray(pointer => __liftRecord50(__getU32(pointer)), 2, exports.getGasCosts(input, kind, withMetadata) >>> 0);
+    },
+    disassemble(input, kind, withMetadata) {
+      // assembly/api-utils/disassemble(~lib/array/Array<u8>, i32, i32) => ~lib/string/String
+      input = __lowerArray(__setU8, 6, 0, input) || __notnull();
+      return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0);
+    },
+    prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) {
+      // assembly/api-utils/prepareProgram(i32, i32, ~lib/array/Array<u8>, ~lib/array/Array<u64>, ~lib/array/Array<assembly/api-internal/InitialPage>, ~lib/array/Array<assembly/api-internal/InitialChunk>, ~lib/array/Array<u8>) => assembly/spi/StandardProgram
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      initialRegisters = __retain(__lowerArray(__setU64, 52, 3, initialRegisters) || __notnull());
+      initialPageMap = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord46(value) || __notnull()); }, 47, 2, initialPageMap) || __notnull());
+      initialMemory = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, initialMemory) || __notnull());
+      args = __lowerArray(__setU8, 6, 0, args) || __notnull();
+      try {
+        return __liftInternref(exports.prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) >>> 0);
+      } finally {
+        __release(program);
+        __release(initialRegisters);
+        __release(initialPageMap);
+        __release(initialMemory);
+      }
+    },
+    runProgram(program, initialGas, programCounter, logs, useSbrkGas) {
+      // assembly/api-utils/runProgram(assembly/spi/StandardProgram, i64?, u32?, bool?, bool?) => assembly/api-internal/VmOutput
+      program = __lowerInternref(program) || __notnull();
+      initialGas = initialGas || 0n;
+      logs = logs ? 1 : 0;
+      useSbrkGas = useSbrkGas ? 1 : 0;
+      exports.__setArgumentsLength(arguments.length);
+      return __liftRecord55(exports.runProgram(program, initialGas, programCounter, logs, useSbrkGas) >>> 0);
+    },
+  }, exports);
+  function __liftRecord50(pointer) {
+    // assembly/gas-costs/BlockGasCost
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      pc: __getU32(pointer + 0),
+      gas: __getU64(pointer + 8),
+    };
+  }
+  function __lowerRecord46(value) {
+    // assembly/api-internal/InitialPage
+    // Hint: Opt-out from lowering as a record by providing an empty constructor
+    if (value == null) return 0;
+    const pointer = exports.__pin(exports.__new(12, 46));
+    __setU32(pointer + 0, value.address);
+    __setU32(pointer + 4, value.length);
+    __setU32(pointer + 8, value.access);
+    exports.__unpin(pointer);
+    return pointer;
+  }
+  function __lowerRecord48(value) {
+    // assembly/api-internal/InitialChunk
+    // Hint: Opt-out from lowering as a record by providing an empty constructor
+    if (value == null) return 0;
+    const pointer = exports.__pin(exports.__new(8, 48));
+    __setU32(pointer + 0, value.address);
+    __setU32(pointer + 4, __lowerArray(__setU8, 6, 0, value.data) || __notnull());
+    exports.__unpin(pointer);
+    return pointer;
+  }
+  function __liftRecord48(pointer) {
+    // assembly/api-internal/InitialChunk
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      address: __getU32(pointer + 0),
+      data: __liftArray(__getU8, 0, __getU32(pointer + 4)),
+    };
+  }
+  function __liftRecord55(pointer) {
+    // assembly/api-internal/VmOutput
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      status: __getI32(pointer + 0),
+      registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)),
+      pc: __getU32(pointer + 8),
+      memory: __liftArray(pointer => __liftRecord48(__getU32(pointer)), 2, __getU32(pointer + 12)),
+      gas: __getI64(pointer + 16),
+      exitCode: __getU32(pointer + 24),
+    };
+  }
+  function __liftString(pointer) {
+    if (!pointer) return null;
+    const
+      end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1,
+      memoryU16 = new Uint16Array(memory.buffer);
+    let
+      start = pointer >>> 1,
+      string = "";
+    while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
+    return string + String.fromCharCode(...memoryU16.subarray(start, end));
+  }
+  function __liftArray(liftElement, align, pointer) {
+    if (!pointer) return null;
+    const
+      dataStart = __getU32(pointer + 4),
+      length = __dataview.getUint32(pointer + 12, true),
+      values = new Array(length);
+    for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0));
+    return values;
+  }
+  function __lowerArray(lowerElement, id, align, values) {
+    if (values == null) return 0;
+    const
+      length = values.length,
+      buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
+      header = exports.__pin(exports.__new(16, id)) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    __dataview.setUint32(header + 12, length, true);
+    for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]);
+    exports.__unpin(buffer);
+    exports.__unpin(header);
+    return header;
+  }
+  function __liftTypedArray(constructor, pointer) {
+    if (!pointer) return null;
+    return new constructor(
+      memory.buffer,
+      __getU32(pointer + 4),
+      __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT
+    ).slice();
+  }
+  function __lowerTypedArray(constructor, id, align, values) {
+    if (values == null) return 0;
+    const
+      length = values.length,
+      buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
+      header = exports.__new(12, id) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    new constructor(memory.buffer, buffer, length).set(values);
+    exports.__unpin(buffer);
+    return header;
+  }
+  class Internref extends Number {}
+  const registry = new FinalizationRegistry(__release);
+  function __liftInternref(pointer) {
+    if (!pointer) return null;
+    const sentinel = new Internref(__retain(pointer));
+    registry.register(sentinel, pointer);
+    return sentinel;
+  }
+  function __lowerInternref(value) {
+    if (value == null) return 0;
+    if (value instanceof Internref) return value.valueOf();
+    throw TypeError("internref expected");
+  }
+  const refcounts = new Map();
+  function __retain(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount) refcounts.set(pointer, refcount + 1);
+      else refcounts.set(exports.__pin(pointer), 1);
+    }
+    return pointer;
+  }
+  function __release(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer);
+      else if (refcount) refcounts.set(pointer, refcount - 1);
+      else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`);
+    }
+  }
+  function __notnull() {
+    throw TypeError("value must not be null");
+  }
+  let __dataview = new DataView(memory.buffer);
+  function __setU8(pointer, value) {
+    try {
+      __dataview.setUint8(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint8(pointer, value, true);
+    }
+  }
+  function __setU32(pointer, value) {
+    try {
+      __dataview.setUint32(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint32(pointer, value, true);
+    }
+  }
+  function __setU64(pointer, value) {
+    try {
+      __dataview.setBigUint64(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setBigUint64(pointer, value, true);
+    }
+  }
+  function __getU8(pointer) {
+    try {
+      return __dataview.getUint8(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint8(pointer, true);
+    }
+  }
+  function __getI32(pointer) {
+    try {
+      return __dataview.getInt32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getInt32(pointer, true);
+    }
+  }
+  function __getU32(pointer) {
+    try {
+      return __dataview.getUint32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint32(pointer, true);
+    }
+  }
+  function __getI64(pointer) {
+    try {
+      return __dataview.getBigInt64(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getBigInt64(pointer, true);
+    }
+  }
+  function __getU64(pointer) {
+    try {
+      return __dataview.getBigUint64(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getBigUint64(pointer, true);
+    }
+  }
+  return adaptedExports;
+}
+export const {
+  memory,
+  getAssembly,
+  wrapAsProgram,
+  resetJAM,
+  resetGeneric,
+  resetGenericWithMemory,
+  nextStep,
+  nSteps,
+  getProgramCounter,
+  setNextProgramCounter,
+  getStatus,
+  getExitArg,
+  getGasLeft,
+  setGasLeft,
+  getRegisters,
+  setRegisters,
+  getPageDump,
+  setMemory,
+  InputKind,
+  HasMetadata,
+  getGasCosts,
+  disassemble,
+  prepareProgram,
+  runProgram,
+} = await (async url => instantiate(
+  await (async () => {
+    const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null);
+    if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); }
+    else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); }
+  })(), {
+  }
+))(new URL("debug.wasm", import.meta.url));