@wasmgroundup/emit 1.0.2 → 2.1.0

package/index.d.ts

@@ -0,0 +1,456 @@
+export type Byte = number;
+export type Bytes = readonly Byte[];
+
+export type Fragment = readonly (Byte | Bytes | Fragment)[];
+
+export type SectionId =
+  | typeof SECTION_ID_CUSTOM
+  | typeof SECTION_ID_TYPE
+  | typeof SECTION_ID_IMPORT
+  | typeof SECTION_ID_FUNCTION
+  | typeof SECTION_ID_TABLE
+  | typeof SECTION_ID_MEMORY
+  | typeof SECTION_ID_GLOBAL
+  | typeof SECTION_ID_EXPORT
+  | typeof SECTION_ID_START
+  | typeof SECTION_ID_ELEMENT
+  | typeof SECTION_ID_CODE
+  | typeof SECTION_ID_DATA;
+
+declare const brand: unique symbol;
+type Brand<T, B extends string> = T & {readonly [brand]: B};
+
+export type typeidx = Brand<Bytes, 'typeidx'>;
+export type funcidx = Brand<Bytes, 'funcidx'>;
+export type localidx = Brand<Bytes, 'localidx'>;
+export type globalidx = Brand<Bytes, 'globalidx'>;
+export type tableidx = Brand<Bytes, 'tableidx'>;
+export type labelidx = Brand<Bytes, 'labelidx'>;
+export type memidx = Brand<Bytes, 'memidx'>;
+export type idx =
+  | typeidx
+  | funcidx
+  | localidx
+  | globalidx
+  | tableidx
+  | labelidx
+  | memidx;
+
+export function stringToBytes(s: string): Bytes;
+
+export function magic(): Bytes;
+export function version(): Bytes;
+
+export function u32(v: number): Bytes;
+export function i32(v: number): Bytes;
+
+export function section(id: SectionId, contents: Fragment): Fragment;
+export function vec(elements: Fragment): Fragment;
+
+// Type section
+// ------------
+
+export const SECTION_ID_TYPE: 1;
+
+export type valtype = Brand<number, 'valtype'>;
+
+export const valtype: {
+  i32: valtype;
+  i64: valtype;
+  f32: valtype;
+  f64: valtype;
+};
+
+export function functype(
+  paramTypes: readonly valtype[],
+  resultTypes: readonly valtype[],
+): Fragment;
+
+export function typesec(functypes: readonly Fragment[]): Fragment;
+
+// Function section and indices
+// ----------------------------
+
+export const SECTION_ID_FUNCTION: 3;
+
+export function typeidx(x: number): typeidx;
+export function funcidx(x: number): funcidx;
+export function localidx(x: number): localidx;
+export function labelidx(x: number): labelidx;
+export function tableidx(x: number): tableidx;
+export function globalidx(x: number): globalidx;
+export function memidx(x: number): memidx;
+
+export function funcsec(typeidxs: readonly typeidx[]): Fragment;
+
+// Code section
+// ------------
+
+export const SECTION_ID_CODE: 10;
+
+export function code(func: Fragment): Fragment;
+
+export function func(locals: readonly Fragment[], body: Fragment): Fragment;
+
+export function expr(instrs: readonly Fragment[]): Fragment;
+
+export function codesec(codes: readonly Fragment[]): Fragment;
+
+// Instructions etc.
+// -----------------
+
+// Autogenerated by scripts/gen_instr_type.js. Do not edit manually.
+export const instr: {
+  readonly end: 0x0b;
+  i32: {
+    readonly const: 0x41;
+    readonly add: 0x6a;
+    readonly sub: 0x6b;
+    readonly mul: 0x6c;
+    readonly div_s: 0x6d;
+    readonly eq: 0x46;
+    readonly ne: 0x47;
+    readonly lt_s: 0x48;
+    readonly lt_u: 0x49;
+    readonly gt_s: 0x4a;
+    readonly gt_u: 0x4b;
+    readonly le_s: 0x4c;
+    readonly le_u: 0x4d;
+    readonly ge_s: 0x4e;
+    readonly ge_u: 0x4f;
+    readonly eqz: 0x45;
+    readonly and: 0x71;
+    readonly or: 0x72;
+    readonly load: 0x28;
+    readonly store: 0x36;
+    readonly load8_s: 0x2c;
+    readonly load8_u: 0x2d;
+    readonly load16_s: 0x2e;
+    readonly load16_u: 0x2f;
+    readonly store8: 0x3a;
+    readonly store16: 0x3b;
+    readonly clz: 0x67;
+    readonly ctz: 0x68;
+    readonly popcnt: 0x69;
+    readonly div_u: 0x6e;
+    readonly rem_s: 0x6f;
+    readonly rem_u: 0x70;
+    readonly xor: 0x73;
+    readonly shl: 0x74;
+    readonly shr_s: 0x75;
+    readonly shr_u: 0x76;
+    readonly rotl: 0x77;
+    readonly rotr: 0x78;
+    readonly wrap_i64: 0xa7;
+    readonly trunc_f32_s: 0xa8;
+    readonly trunc_f32_u: 0xa9;
+    readonly trunc_f64_s: 0xaa;
+    readonly trunc_f64_u: 0xab;
+    readonly reinterpret_f32: 0xbc;
+  };
+  i64: {
+    readonly const: 0x42;
+    readonly load: 0x29;
+    readonly load8_s: 0x30;
+    readonly load8_u: 0x31;
+    readonly load16_s: 0x32;
+    readonly load16_u: 0x33;
+    readonly load32_s: 0x34;
+    readonly load32_u: 0x35;
+    readonly store: 0x37;
+    readonly store8: 0x3c;
+    readonly store16: 0x3d;
+    readonly store32: 0x3e;
+    readonly eqz: 0x50;
+    readonly eq: 0x51;
+    readonly ne: 0x52;
+    readonly lt_s: 0x53;
+    readonly lt_u: 0x54;
+    readonly gt_s: 0x55;
+    readonly gt_u: 0x56;
+    readonly le_s: 0x57;
+    readonly le_u: 0x58;
+    readonly ge_s: 0x59;
+    readonly ge_u: 0x5a;
+    readonly clz: 0x79;
+    readonly ctz: 0x7a;
+    readonly popcnt: 0x7b;
+    readonly add: 0x7c;
+    readonly sub: 0x7d;
+    readonly mul: 0x7e;
+    readonly div_s: 0x7f;
+    readonly div_u: 0x80;
+    readonly rem_s: 0x81;
+    readonly rem_u: 0x82;
+    readonly and: 0x83;
+    readonly or: 0x84;
+    readonly xor: 0x85;
+    readonly shl: 0x86;
+    readonly shr_s: 0x87;
+    readonly shr_u: 0x88;
+    readonly rotl: 0x89;
+    readonly rotr: 0x8a;
+    readonly extend_i32_s: 0xac;
+    readonly extend_i32_u: 0xad;
+    readonly trunc_f32_s: 0xae;
+    readonly trunc_f32_u: 0xaf;
+    readonly trunc_f64_s: 0xb0;
+    readonly trunc_f64_u: 0xb1;
+    readonly reinterpret_f64: 0xbd;
+  };
+  f32: {
+    readonly const: 0x43;
+    readonly load: 0x2a;
+    readonly store: 0x38;
+    readonly eq: 0x5b;
+    readonly ne: 0x5c;
+    readonly lt: 0x5d;
+    readonly gt: 0x5e;
+    readonly le: 0x5f;
+    readonly ge: 0x60;
+    readonly abs: 0x8b;
+    readonly neg: 0x8c;
+    readonly ceil: 0x8d;
+    readonly floor: 0x8e;
+    readonly trunc: 0x8f;
+    readonly nearest: 0x90;
+    readonly sqrt: 0x91;
+    readonly add: 0x92;
+    readonly sub: 0x93;
+    readonly mul: 0x94;
+    readonly div: 0x95;
+    readonly min: 0x96;
+    readonly max: 0x97;
+    readonly copysign: 0x98;
+    readonly convert_i32_s: 0xb2;
+    readonly convert_i32_u: 0xb3;
+    readonly convert_i64_s: 0xb4;
+    readonly convert_i64_u: 0xb5;
+    readonly demote_f64: 0xb6;
+    readonly reinterpret_i32: 0xbe;
+  };
+  f64: {
+    readonly const: 0x44;
+    readonly load: 0x2b;
+    readonly store: 0x39;
+    readonly eq: 0x61;
+    readonly ne: 0x62;
+    readonly lt: 0x63;
+    readonly gt: 0x64;
+    readonly le: 0x65;
+    readonly ge: 0x66;
+    readonly abs: 0x99;
+    readonly neg: 0x9a;
+    readonly ceil: 0x9b;
+    readonly floor: 0x9c;
+    readonly trunc: 0x9d;
+    readonly nearest: 0x9e;
+    readonly sqrt: 0x9f;
+    readonly add: 0xa0;
+    readonly sub: 0xa1;
+    readonly mul: 0xa2;
+    readonly div: 0xa3;
+    readonly min: 0xa4;
+    readonly max: 0xa5;
+    readonly copysign: 0xa6;
+    readonly convert_i32_s: 0xb7;
+    readonly convert_i32_u: 0xb8;
+    readonly convert_i64_s: 0xb9;
+    readonly convert_i64_u: 0xba;
+    readonly promote_f32: 0xbb;
+    readonly reinterpret_i64: 0xbf;
+  };
+  local: {
+    readonly get: 0x20;
+    readonly set: 0x21;
+    readonly tee: 0x22;
+  };
+  readonly drop: 0x1a;
+  readonly call: 0x10;
+  readonly if: 0x04;
+  readonly else: 0x05;
+  readonly block: 0x02;
+  readonly loop: 0x03;
+  readonly br: 0x0c;
+  readonly br_if: 0x0d;
+  memory: {
+    readonly size: 0x3f;
+    readonly grow: 0x40;
+  };
+  readonly unreachable: 0x00;
+  global: {
+    readonly get: 0x23;
+    readonly set: 0x24;
+  };
+  readonly call_indirect: 0x11;
+  readonly nop: 0x01;
+  readonly br_table: 0x0e;
+  readonly return: 0x0f;
+  readonly select: 0x1b;
+};
+// End of autogenerated instruction types.
+
+export const blocktype: {readonly empty: 0x40} & typeof valtype;
+
+export type blocktype = typeof blocktype.empty | valtype | Fragment;
+
+// Export section
+// --------------
+
+export const SECTION_ID_EXPORT: 7;
+
+export function name(s: string): Fragment;
+
+export function export_(nm: string, exportdesc: Fragment): Fragment;
+
+export function exportsec(exports: readonly Fragment[]): Fragment;
+
+export const exportdesc: {
+  func(idx: funcidx): Fragment;
+  mem(idx: memidx): Fragment;
+};
+
+// Module
+// ------
+
+export type WasmModule = Fragment;
+
+export function module(sections: readonly Fragment[]): WasmModule;
+
+export function flatten(fragment: Fragment): Uint8Array<ArrayBuffer>;
+
+// Locals
+// ------
+
+export function locals(n: number, type: valtype): Fragment;
+
+// Imports
+// -------
+
+export const SECTION_ID_IMPORT: 2;
+
+export function import_(mod: string, nm: string, d: Fragment): Fragment;
+
+export function importsec(ims: readonly Fragment[]): Fragment;
+
+export const importdesc: {
+  func(x: typeidx): Fragment;
+};
+
+// Memory
+// ------
+
+export const SECTION_ID_MEMORY: 5;
+
+export function memsec(mems: readonly Fragment[]): Fragment;
+
+export function mem(memtype: Fragment): Fragment;
+
+export function memtype(limits: Fragment): Fragment;
+
+export const limits: {
+  min(n: number): Fragment;
+  minmax(n: number, m: number): Fragment;
+};
+
+export function memarg(align: number, offset: number): Fragment;
+
+// Data / custom / names
+// ---------------------
+
+export const SECTION_ID_DATA: 11;
+
+export function data(x: memidx, e: Fragment, bs: Bytes): Fragment;
+
+export function datasec(segs: readonly Fragment[]): Fragment;
+
+export const SECTION_ID_CUSTOM: 0;
+
+export function custom(nameBytes: Fragment, payload: Fragment): Fragment;
+export function customsec(custom: Fragment): Fragment;
+
+export function namesec(namedata: Fragment): Fragment;
+
+export function namedata(
+  modulenamesubsec: Fragment,
+  funcnamesubsec: Fragment,
+  localnamesubsec: Fragment,
+): Fragment;
+
+export type NameSubsectionId =
+  | typeof CUSTOM_NAME_SUB_SEC_MODULE
+  | typeof CUSTOM_NAME_SUB_SEC_FUNC
+  | typeof CUSTOM_NAME_SUB_SEC_LOCAL;
+
+export const CUSTOM_NAME_SUB_SEC_MODULE: 0;
+export function modulenamesubsec(n: string): Fragment;
+
+export const CUSTOM_NAME_SUB_SEC_FUNC: 1;
+export function funcnamesubsec(namemap: Fragment): Fragment;
+
+export function namesubsection(N: NameSubsectionId, B: Fragment): Fragment;
+
+export function namemap(nameassocs: readonly Fragment[]): Fragment;
+
+export function nameassoc(idx: idx, n: string): Fragment;
+
+export const CUSTOM_NAME_SUB_SEC_LOCAL: 2;
+export function localnamesubsec(indirectnamemap: Fragment): Fragment;
+
+export function indirectnamemap(
+  indirectnameassocs: readonly Fragment[],
+): Fragment;
+
+export function indirectnameassoc(idx: funcidx, namemap: Fragment): Fragment;
+
+// Start section
+// -------------
+
+export const SECTION_ID_START: 8;
+
+export function start(x: number): funcidx;
+
+export function startsec(st: funcidx): Fragment;
+
+// Globals
+// -------
+
+export const SECTION_ID_GLOBAL: 6;
+
+export type mut = Brand<number, 'mut'>;
+
+export const mut: {
+  const: mut;
+  var: mut;
+};
+
+export function globaltype(t: valtype, m: mut): Fragment;
+
+export function global(gt: Fragment, e: Fragment): Fragment;
+
+export function globalsec(globs: readonly Fragment[]): Fragment;
+
+// Tables / elements
+// -----------------
+
+export const SECTION_ID_TABLE: 4;
+
+export const elemtype: {
+  readonly funcref: 0x70;
+};
+
+export function tabletype(et: typeof elemtype.funcref, lim: Fragment): Fragment;
+
+export function table(tt: Fragment): Fragment;
+
+export function tablesec(tables: readonly Fragment[]): Fragment;
+
+export const SECTION_ID_ELEMENT: 9;
+
+export function elem(
+  x: tableidx,
+  e: Fragment,
+  ys: readonly funcidx[],
+): Fragment;
+
+export function elemsec(segs: readonly Fragment[]): Fragment;

package/index.js

@@ -1,5 +1,26 @@
 // WebAssembly 1.0 Module Builder
 // https://wasmgroundup.com/
+
+function byteLength(fragment) {
+  let n = 0;
+  for (const item of fragment) {
+    if (Array.isArray(item)) n += byteLength(item);
+    else n += 1;
+  }
+  return n;
+}
+
+function writeInto(fragment, out, offset) {
+  for (const item of fragment) {
+    if (Array.isArray(item)) {
+      offset = writeInto(item, out, offset);
+    } else {
+      out[offset++] = item;
+    }
+  }
+  return offset;
+}
+
 export function stringToBytes(s) {
   const bytes = new TextEncoder().encode(s);
   return Array.from(bytes);
@@ -86,7 +107,7 @@ export function i32(v) {
 }
 
 export function section(id, contents) {
-  const sizeInBytes = contents.flat(Infinity).length;
+  const sizeInBytes = byteLength(contents);
   return [id, u32(sizeInBytes), contents];
 }
 
@@ -115,12 +136,16 @@ export function funcsec(typeidxs) {
 export const SECTION_ID_CODE = 10;
 
 export function code(func) {
-  const sizeInBytes = func.flat(Infinity).length;
+  const sizeInBytes = byteLength(func);
   return [u32(sizeInBytes), func];
 }
 
-export function func(locals, body) {
-  return [vec(locals), body];
+export function func(locals, e) {
+  return [vec(locals), e];
+}
+
+export function expr(instrs) {
+  return [...instrs, instr.end];
 }
 
 export function codesec(codes) {
@@ -149,13 +174,19 @@ export const funcidx = (x) => u32(x);
 
 export const exportdesc = {
   func(idx) {
-    return [0x00, funcidx(idx)];
+    return [0x00, idx];
   },
 };
 
 export function module(sections) {
   return [magic(), version(), sections];
 }
+
+export function flatten(fragment) {
+  const out = new Uint8Array(byteLength(fragment));
+  writeInto(fragment, out, 0);
+  return out;
+}
 export const valtype = {
   i32: 0x7f,
   i64: 0x7e,
@@ -226,7 +257,7 @@ export function importsec(ims) {
 export const importdesc = {
   // x:typeidx
   func(x) {
-    return [0x00, typeidx(x)];
+    return [0x00, x];
   },
 };
 export const SECTION_ID_MEMORY = 5;
@@ -256,7 +287,7 @@ export const limits = {
 
 export const memidx = u32;
 
-exportdesc.mem = (idx) => [0x02, memidx(idx)];
+exportdesc.mem = (idx) => [0x02, idx];
 
 instr.memory = {
   size: 0x3f, // [] -> [i32]
@@ -317,9 +348,8 @@ export function funcnamesubsec(namemap) {
 
 // N:byte
 export function namesubsection(N, B) {
-  const flatB = B.flat(Infinity);
-  const size = u32(flatB.length);
-  return [N, size, flatB];
+  const size = u32(byteLength(B));
+  return [N, size, B];
 }
 
 export function namemap(nameassocs) {

package/package.json

@@ -1,9 +1,20 @@
 {
   "name": "@wasmgroundup/emit",
   "description": "A library for creating binary-encoded WebAssembly modules",
-  "version": "1.0.2",
+  "version": "2.1.0",
   "type": "module",
   "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/wasmgroundup/emit.git"
@@ -17,5 +28,16 @@
   "bugs": {
     "url": "https://github.com/wasmgroundup/emit/issues"
   },
-  "homepage": "https://github.com/wasmgroundup/emit#readme"
-}
+  "homepage": "https://github.com/wasmgroundup/emit#readme",
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "format": "npx prettier '**/*.{ts,js,json}' --write",
+    "test": "node --test",
+    "test:watch": "node --test --watch"
+  }
+}

package/index.test.ts

@@ -1,229 +0,0 @@
-import { expect, test } from "bun:test";
-
-import {
-  blocktype,
-  code,
-  codesec,
-  export_,
-  exportdesc,
-  exportsec,
-  func,
-  funcidx,
-  funcsec,
-  functype,
-  global,
-  globalsec,
-  globaltype,
-  i32,
-  import_,
-  importdesc,
-  importsec,
-  instr,
-  module,
-  mut,
-  typeidx,
-  typesec,
-  u32,
-  valtype,
-} from "./index.js";
-
-function blocktype(t?: valtype): number {
-  return t ?? 0x40;
-}
-
-function f64(v: number): number[] {
-  var buf = new ArrayBuffer(8);
-  new Float64Array(buf)[0] = v;
-  return Array.from(new Uint8Array(buf));
-}
-
-const PI = 3.141592653589793115997963468544185161590576171875;
-
-function fragmentToUInt8Array(frag): Uint8Array {
-  return Uint8Array.from((frag as any).flat(Infinity));
-}
-
-test("u32", () => {
-  expect(u32(32768)).toEqual([128, 128, 2]);
-  expect(u32(2 ** 32 - 1)).toEqual([255, 255, 255, 255, 15]);
-});
-
-test("i32", () => {
-  expect(i32(32768)).toEqual([128, 128, 2]);
-  expect(i32(2 ** 31 - 1)).toEqual([255, 255, 255, 255, 7]);
-  expect(i32(-(2 ** 31 - 1))).toEqual([129, 128, 128, 128, 120]);
-});
-
-test("simple modules", async () => {
-  const makeModule = (paramTypes, resultTypes, body) => {
-    const mod = module([
-      typesec([functype(paramTypes, resultTypes)]),
-      funcsec([typeidx(0)]),
-      exportsec([export_("main", exportdesc.func(0))]),
-      codesec([code(func([], body))]),
-    ]);
-    return fragmentToUInt8Array(mod);
-  };
-  const runMain = async (bytes, args) => {
-    const { instance } = await WebAssembly.instantiate(bytes);
-    return instance.exports.main(...args);
-  };
-
-  // () => ()
-  expect(await runMain(makeModule([], [], [instr.end]), [])).toBe(undefined);
-
-  // () => i32
-  expect(
-    await runMain(
-      makeModule([], [valtype.i32], [instr.i32.const, 1, instr.end]),
-      [],
-    ),
-  ).toBe(1);
-
-  // (i32) => i32
-  expect(
-    await runMain(
-      makeModule([valtype.i32], [valtype.i32], [instr.local.get, 0, instr.end]),
-      [1],
-    ),
-  ).toBe(1);
-  expect(
-    await runMain(
-      makeModule([valtype.i32], [valtype.i32], [instr.local.get, 0, instr.end]),
-      [99],
-    ),
-  ).toBe(99);
-});
-
-test("imports", async () => {
-  const makeModule = () => {
-    const mod = module([
-      typesec([functype([valtype.i32], [valtype.i32])]),
-      importsec([import_("builtins", "addOne", importdesc.func(0))]),
-      funcsec([typeidx(0)]),
-      exportsec([export_("main", exportdesc.func(1))]),
-      codesec([
-        code(func([], [instr.local.get, 0, instr.call, funcidx(0), instr.end])),
-      ]),
-    ]);
-    return fragmentToUInt8Array(mod);
-  };
-
-  const { instance } = await WebAssembly.instantiate(makeModule(), {
-    builtins: {
-      addOne(x) {
-        return x + 1;
-      },
-    },
-  });
-
-  expect(instance.exports.main(1)).toBe(2);
-  expect(instance.exports.main(2)).toBe(3);
-});
-
-test("f64", async () => {
-  const makeModule = () => {
-    const mod = module([
-      typesec([functype([], [valtype.f64])]),
-      funcsec([typeidx(0), typeidx(0), typeidx(0)]),
-      exportsec([
-        export_("pi", exportdesc.func(0)),
-        export_("nan", exportdesc.func(1)),
-        export_("one", exportdesc.func(2)),
-      ]),
-      codesec([
-        code(func([], [instr.f64.const, f64(PI), instr.end])),
-        code(func([], [instr.f64.const, f64(Number.NaN), instr.end])),
-        code(func([], [instr.f64.const, f64(1), instr.end])),
-      ]),
-    ]);
-    return fragmentToUInt8Array(mod);
-  };
-  const { instance } = await WebAssembly.instantiate(makeModule());
-  expect(instance.exports.pi()).toBe(PI);
-  expect(instance.exports.nan()).toBe(Number.NaN);
-  expect(instance.exports.one()).toBe(1);
-});
-
-test("globals", async () => {
-  const makeModule = () => {
-    const mod = module([
-      typesec([
-        functype([], [valtype.f64]), // pi
-        functype([], [valtype.i32]), // getVar
-        functype([], []), // incVar
-      ]),
-      funcsec([typeidx(0), typeidx(1), typeidx(2)]),
-      globalsec([
-        global(globaltype(valtype.f64, mut.const), [
-          instr.f64.const,
-          f64(PI),
-          instr.end,
-        ]),
-        global(globaltype(valtype.i32, mut.var), [
-          instr.i32.const,
-          i32(0),
-          instr.end,
-        ]),
-      ]),
-      exportsec([
-        export_("pi", exportdesc.func(0)),
-        export_("getVar", exportdesc.func(1)),
-        export_("incVar", exportdesc.func(2)),
-      ]),
-      codesec([
-        code(func([], [instr.global.get, 0, instr.end])), // pi
-        code(func([], [instr.global.get, 1, instr.end])), // getVar
-        code(
-          // prettier-ignore
-          func([], [
-              instr.global.get, 1,
-              instr.i32.const, 1,
-              instr.i32.add,
-              instr.global.set, 1,
-              instr.end,
-            ],
-          ),
-        ), // incVar
-      ]),
-    ]);
-    return fragmentToUInt8Array(mod);
-  };
-
-  const { exports } = (await WebAssembly.instantiate(makeModule())).instance;
-  expect(exports.pi()).toBe(PI);
-  expect(exports.getVar()).toBe(0);
-  exports.incVar();
-  expect(exports.getVar()).toBe(1);
-});
-
-test("if", async () => {
-  const makeModule = () => {
-    const mod = module([
-      typesec([functype([valtype.i32], [valtype.f64])]),
-      funcsec([typeidx(0)]),
-      exportsec([export_("maybePi", exportdesc.func(0))]),
-      codesec([
-        code(
-          func(
-            [],
-            // prettier-ignore
-            [
-              instr.local.get, 0,
-              instr.if, blocktype(valtype.f64),
-              instr.f64.const, f64(PI),
-              instr.else,
-              instr.f64.const, f64(0),
-              instr.end,
-              instr.end,
-            ],
-          ),
-        ),
-      ]),
-    ]);
-    return fragmentToUInt8Array(mod);
-  };
-  const { exports } = (await WebAssembly.instantiate(makeModule())).instance;
-  expect(exports.maybePi(1)).toBe(PI);
-  expect(exports.maybePi(0)).toBe(0);
-});