@wasmgroundup/emit 0.2.17 → 0.3.2

package/index.js

@@ -0,0 +1,393 @@
+// WebAssembly 1.0 Module Builder
+// https://wasmgroundup.com/
+export function stringToBytes(s) {
+  const bytes = new TextEncoder().encode(s);
+  return Array.from(bytes);
+}
+
+export function magic() {
+  // [0x00, 0x61, 0x73, 0x6d]
+  return stringToBytes('\0asm');
+}
+
+export function version() {
+  return [0x01, 0x00, 0x00, 0x00];
+}
+
+export const SEVEN_BIT_MASK_BIG_INT = 0b01111111n;
+export const CONTINUATION_BIT = 0b10000000;
+
+export function u32(v) {
+  assert(v >= 0, `Value is negative: ${v}`);
+
+  let val = BigInt(v);
+  let more = true;
+  const r = [];
+
+  while (more) {
+    const b = Number(val & SEVEN_BIT_MASK_BIG_INT);
+    val = val >> 7n;
+    more = val !== 0n;
+    if (more) {
+      r.push(b | CONTINUATION_BIT);
+    } else {
+      r.push(b);
+    }
+  }
+
+  return r;
+}
+
+export function i32(v) {
+  let val = BigInt(v);
+  const r = [];
+
+  let more = true;
+  while (more) {
+    const b = Number(val & 0b01111111n);
+    const signBitSet = !!(b & 0x40);
+
+    val = val >> 7n;
+
+    if ((val === 0n && !signBitSet) || (val === -1n && signBitSet)) {
+      more = false;
+      r.push(b);
+    } else {
+      r.push(b | CONTINUATION_BIT);
+    }
+  }
+
+  return r;
+}
+
+export function section(id, contents) {
+  const sizeInBytes = contents.flat(Infinity).length;
+  return [id, u32(sizeInBytes), contents];
+}
+
+export function vec(elements) {
+  return [u32(elements.length), elements];
+}
+
+export const SECTION_ID_TYPE = 1;
+
+export function functype(paramTypes, resultTypes) {
+  return [0x60, vec(paramTypes), vec(resultTypes)];
+}
+
+export function typesec(functypes) {
+  return section(SECTION_ID_TYPE, vec(functypes));
+}
+
+export const SECTION_ID_FUNCTION = 3;
+
+export const typeidx = (x) => u32(x);
+
+export function funcsec(typeidxs) {
+  return section(SECTION_ID_FUNCTION, vec(typeidxs));
+}
+
+export const SECTION_ID_CODE = 10;
+
+export function code(func) {
+  const sizeInBytes = func.flat(Infinity).length;
+  return [u32(sizeInBytes), func];
+}
+
+export function func(locals, body) {
+  return [vec(locals), body];
+}
+
+export function codesec(codes) {
+  return section(SECTION_ID_CODE, vec(codes));
+}
+
+export const instr = {
+  end: 0x0b,
+};
+
+export const SECTION_ID_EXPORT = 7;
+
+export function name(s) {
+  return vec(stringToBytes(s));
+}
+
+export function export_(nm, exportdesc) {
+  return [name(nm), exportdesc];
+}
+
+export function exportsec(exports) {
+  return section(SECTION_ID_EXPORT, vec(exports));
+}
+
+export const funcidx = (x) => u32(x);
+
+export const exportdesc = {
+  func(idx) {
+    return [0x00, funcidx(idx)];
+  },
+};
+
+export function module(sections) {
+  return [magic(), version(), sections];
+}
+export const valtype = {
+  i32: 0x7f,
+  i64: 0x7e,
+  f32: 0x7d,
+  f64: 0x7c,
+};
+
+instr.i32 = {const: 0x41};
+instr.i64 = {const: 0x42};
+instr.f32 = {const: 0x43};
+instr.f64 = {const: 0x44};
+instr.i32.add = 0x6a;
+instr.i32.sub = 0x6b;
+instr.i32.mul = 0x6c;
+instr.i32.div_s = 0x6d;
+instr.local = {};
+instr.local.get = 0x20;
+instr.local.set = 0x21;
+instr.local.tee = 0x22;
+
+export function locals(n, type) {
+  return [u32(n), type];
+}
+
+export const localidx = (x) => u32(x);
+
+instr.drop = 0x1a;
+instr.call = 0x10;
+instr.if = 0x04;
+instr.else = 0x05;
+
+export const blocktype = {empty: 0x40, ...valtype};
+
+instr.i32.eq = 0x46; // a == b
+instr.i32.ne = 0x47; // a != b
+instr.i32.lt_s = 0x48; // a < b (signed)
+instr.i32.lt_u = 0x49; // a < b (unsigned)
+instr.i32.gt_s = 0x4a; // a > b (signed)
+instr.i32.gt_u = 0x4b; // a > b (unsigned)
+instr.i32.le_s = 0x4c; // a <= b (signed)
+instr.i32.le_u = 0x4d; // a <= b (unsigned)
+instr.i32.ge_s = 0x4e; // a >= b (signed)
+instr.i32.ge_u = 0x4f; // a >= b (unsigned)
+
+instr.i32.eqz = 0x45; // a == 0
+
+instr.i32.and = 0x71;
+instr.i32.or = 0x72;
+
+export const labelidx = u32;
+
+instr.block = 0x02;
+instr.loop = 0x03;
+instr.br = 0x0c;
+instr.br_if = 0x0d;
+export const SECTION_ID_IMPORT = 2;
+
+// mod:name  nm:name  d:importdesc
+export function import_(mod, nm, d) {
+  return [name(mod), name(nm), d];
+}
+
+// im*:vec(import)
+export function importsec(ims) {
+  return section(SECTION_ID_IMPORT, vec(ims));
+}
+
+export const importdesc = {
+  // x:typeidx
+  func(x) {
+    return [0x00, typeidx(x)];
+  },
+};
+export const SECTION_ID_MEMORY = 5;
+
+export function memsec(mems) {
+  return section(SECTION_ID_MEMORY, vec(mems));
+}
+
+export function mem(memtype) {
+  return memtype;
+}
+
+export function memtype(limits) {
+  return limits;
+}
+
+export const limits = {
+  // n:u32
+  min(n) {
+    return [0x00, u32(n)];
+  },
+  // n:u32, m:u32
+  minmax(n, m) {
+    return [0x01, u32(n), u32(m)];
+  },
+};
+
+export const memidx = u32;
+
+exportdesc.mem = (idx) => [0x02, memidx(idx)];
+
+instr.memory = {
+  size: 0x3f, // [] -> [i32]
+  grow: 0x40, // [i32] -> [i32]
+};
+
+instr.i32.load = 0x28; // [i32] -> [i32]
+instr.i32.store = 0x36; // [i32, i32] -> []
+
+// align:u32, offset:u32
+export function memarg(align, offset) {
+  return [u32(align), u32(offset)];
+}
+export function int32ToBytes(v) {
+  return [v & 0xff, (v >> 8) & 0xff, (v >> 16) & 0xff, (v >> 24) & 0xff];
+}
+
+instr.unreachable = 0x00;
+
+export const SECTION_ID_DATA = 11;
+
+// x:memidx  e:expr  bs:vec(byte)
+export function data(x, e, bs) {
+  return [x, e, vec(bs)];
+}
+
+export function datasec(segs) {
+  return section(SECTION_ID_DATA, vec(segs));
+}
+export const SECTION_ID_CUSTOM = 0;
+
+export function custom(name, bytes) {
+  return [name, bytes];
+}
+
+export function customsec(custom) {
+  return section(SECTION_ID_CUSTOM, custom);
+}
+
+export function namesec(namedata) {
+  return customsec(custom(name('name'), namedata));
+}
+
+// n:name
+export function namedata(modulenamesubsec, funcnamesubsec, localnamesubsec) {
+  return [modulenamesubsec, funcnamesubsec, localnamesubsec];
+}
+
+export const CUSTOM_NAME_SUB_SEC_MODULE = 0;
+export function modulenamesubsec(n) {
+  return namesubsection(CUSTOM_NAME_SUB_SEC_MODULE, name(n));
+}
+
+export const CUSTOM_NAME_SUB_SEC_FUNC = 1;
+export function funcnamesubsec(namemap) {
+  return namesubsection(CUSTOM_NAME_SUB_SEC_FUNC, namemap);
+}
+
+// N:byte
+export function namesubsection(N, B) {
+  const flatB = B.flat(Infinity);
+  const size = u32(flatB.length);
+  return [N, size, flatB];
+}
+
+export function namemap(nameassocs) {
+  return vec(nameassocs);
+}
+
+export function nameassoc(idx, n) {
+  return [idx, name(n)];
+}
+
+export const CUSTOM_NAME_SUB_SEC_LOCAL = 2;
+export function localnamesubsec(indirectnamemap) {
+  return namesubsection(CUSTOM_NAME_SUB_SEC_LOCAL, indirectnamemap);
+}
+
+export function indirectnamemap(indirectnameassocs) {
+  return vec(indirectnameassocs);
+}
+
+export function indirectnameassoc(idx, namemap) {
+  return [idx, namemap];
+}
+export const SECTION_ID_START = 8;
+
+export const start = (x) => funcidx(x);
+
+// st:start
+export function startsec(st) {
+  return section(SECTION_ID_START, st);
+}
+
+instr.global = {};
+instr.global.get = 0x23;
+instr.global.set = 0x24;
+
+export const globalidx = (x) => u32(x);
+
+export const SECTION_ID_GLOBAL = 6;
+
+export const mut = {
+  const: 0x00,
+  var: 0x01,
+};
+
+// t:valtype  m:mut
+export function globaltype(t, m) {
+  return [t, m];
+}
+
+// gt:globaltype  e:expr
+export function global(gt, e) {
+  return [gt, e];
+}
+
+// glob*:vec(global)
+export function globalsec(globs) {
+  return section(SECTION_ID_GLOBAL, vec(globs));
+}
+
+export const SECTION_ID_TABLE = 4;
+
+export const elemtype = {funcref: 0x70};
+
+// et:elemtype  lim:limits
+export function tabletype(et, lim) {
+  return [et, lim];
+}
+
+// tt:tabletype
+export function table(tt) {
+  return tt;
+}
+
+export function tablesec(tables) {
+  return section(SECTION_ID_TABLE, vec(tables));
+}
+
+export const tableidx = (x) => u32(x);
+
+instr.call_indirect = 0x11; // [i32] -> []
+
+export const SECTION_ID_ELEMENT = 9;
+
+// x:tableidx  e:expr  y∗:vec(funcidx)
+export function elem(x, e, ys) {
+  return [x, e, vec(ys)];
+}
+
+export function elemsec(segs) {
+  return section(SECTION_ID_ELEMENT, vec(segs));
+}
+export function assert(cond, msg) {
+  if (!cond) {
+    throw new Error(msg);
+  }
+}

package/index.test.ts

@@ -1,14 +1,12 @@
 import { expect, test } from "bun:test";
 
 import {
-  BytecodeFragment,
   blocktype,
   code,
   codesec,
   export_,
   exportdesc,
   exportsec,
-  f64,
   func,
   funcidx,
   funcsec,
@@ -25,15 +23,37 @@ import {
   mut,
   typeidx,
   typesec,
+  u32,
   valtype,
-} from "./index";
+} 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: BytecodeFragment): Uint8Array {
+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([

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@wasmgroundup/emit",
   "description": "A library for creating binary-encoded WebAssembly modules",
-  "version": "0.2.17",
+  "version": "0.3.2",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "index.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/wasmgroundup/emit.git"
@@ -18,16 +17,5 @@
   "bugs": {
     "url": "https://github.com/wasmgroundup/emit/issues"
   },
-  "homepage": "https://github.com/wasmgroundup/emit#readme",
-  "scripts": {
-    "check": "tsc --noEmit",
-    "format": "prettier --write .",
-    "prepublishOnly": "tsc"
-  },
-  "dependencies": {
-    "prettier": "^3.0.3"
-  },
-  "devDependencies": {
-    "typescript": "^5.2.2"
-  }
+  "homepage": "https://github.com/wasmgroundup/emit#readme"
 }

package/dist/index.d.ts

@@ -1,141 +0,0 @@
-type BytecodeFragment = (number | BytecodeFragment)[];
-declare enum valtype {
-    i32 = 127,
-    i64 = 126,
-    f32 = 125,
-    f64 = 124
-}
-declare function blocktype(t?: valtype): number;
-declare function vec<T extends BytecodeFragment>(elements: T): BytecodeFragment;
-declare function section(id: number, contents: BytecodeFragment): (number | BytecodeFragment)[];
-declare function functype(paramTypes: valtype[], resultTypes: valtype[]): BytecodeFragment;
-declare function typesec(functypes: BytecodeFragment): BytecodeFragment;
-declare const typeidx: typeof u32;
-declare function funcsec(typeidxs: BytecodeFragment): BytecodeFragment;
-declare function code(func: BytecodeFragment): BytecodeFragment;
-declare function func(locals: BytecodeFragment, body: BytecodeFragment): BytecodeFragment;
-declare function codesec(codes: BytecodeFragment): BytecodeFragment;
-declare function name(s: string): BytecodeFragment;
-declare function export_(nm: string, exportdesc: BytecodeFragment): BytecodeFragment;
-declare function exportsec(exports: BytecodeFragment): BytecodeFragment;
-declare const funcidx: typeof u32;
-declare const exportdesc: {
-    func(idx: number): BytecodeFragment;
-    table(idx: number): BytecodeFragment;
-    mem(idx: number): BytecodeFragment;
-    global(idx: number): BytecodeFragment;
-};
-declare function module(sections: any): BytecodeFragment;
-declare const instr: {
-    unreachable: number;
-    nop: number;
-    block: number;
-    loop: number;
-    if: number;
-    else: number;
-    end: number;
-    br: number;
-    br_if: number;
-    br_table: number;
-    return: number;
-    call: number;
-    call_indirect: number;
-    drop: number;
-    select: number;
-    local: {
-        get: number;
-        set: number;
-        tee: number;
-    };
-    global: {
-        get: number;
-        set: number;
-        tee: number;
-    };
-    memory: {
-        size: number;
-        grow: number;
-    };
-    i32: {
-        load: number;
-        const: number;
-        eqz: number;
-        eq: number;
-        ne: number;
-        lt_s: number;
-        lt_u: number;
-        gt_s: number;
-        gt_u: number;
-        le_s: number;
-        le_u: number;
-        ge_s: number;
-        ge_u: number;
-        add: number;
-        sub: number;
-        mul: number;
-    };
-    i64: {
-        store32: number;
-        const: number;
-        add: number;
-        sub: number;
-        mul: number;
-    };
-    f32: {
-        const: number;
-        add: number;
-        sub: number;
-        mul: number;
-        div: number;
-    };
-    f64: {
-        load: number;
-        store: number;
-        const: number;
-        add: number;
-        sub: number;
-        mul: number;
-        div: number;
-        reinterpret_i64: number;
-    };
-};
-declare function u32(v: number | bigint): number[];
-declare function i32(v: number | bigint): number[];
-declare function f64(v: number): number[];
-declare function locals(n: number, type: valtype): BytecodeFragment;
-declare function import_(mod: string, nm: string, d: BytecodeFragment): BytecodeFragment;
-declare function importsec(ims: BytecodeFragment): BytecodeFragment;
-declare const importdesc: {
-    func(x: BytecodeFragment): BytecodeFragment;
-    table(tt: BytecodeFragment): BytecodeFragment;
-    mem(mt: BytecodeFragment): BytecodeFragment;
-    global(gt: BytecodeFragment): BytecodeFragment;
-};
-declare function memsec(mems: BytecodeFragment[]): (number | BytecodeFragment)[];
-declare function memtype(limits: BytecodeFragment): BytecodeFragment;
-declare const limits: {
-    min(n: number): (number | number[])[];
-    minmax(n: number, m: number): (number | number[])[];
-};
-declare const mut: {
-    const: number;
-    var: number;
-};
-declare function globaltype(t: any, m: any): any[];
-declare function global(gt: any, e: any): any[];
-declare function globalsec(globs: BytecodeFragment[]): (number | BytecodeFragment)[];
-declare function tabletype(elemtype: number, limits: BytecodeFragment): (number | BytecodeFragment)[];
-declare function table(tabletype: BytecodeFragment): BytecodeFragment;
-declare function tablesec(tables: BytecodeFragment[]): (number | BytecodeFragment)[];
-declare const elemtype: {
-    funcref: number;
-};
-declare const tableidx: typeof u32;
-declare const start: typeof u32;
-declare function startsec(st: BytecodeFragment): (number | BytecodeFragment)[];
-declare function data(x: BytecodeFragment, e: BytecodeFragment, bs: BytecodeFragment[]): BytecodeFragment[];
-declare function datasec(segs: BytecodeFragment[]): (number | BytecodeFragment)[];
-declare function elem(x: BytecodeFragment, e: BytecodeFragment, ys: BytecodeFragment[]): BytecodeFragment[];
-declare function elemsec(segs: BytecodeFragment[]): (number | BytecodeFragment)[];
-declare function memarg(align: number, offset: number): number[][];
-export { blocktype, BytecodeFragment, code, codesec, data, datasec, elem, elemsec, elemtype, export_, exportdesc, exportsec, f64, func, funcidx, funcsec, functype, global, globalsec, globaltype, i32, import_, importdesc, importsec, instr, limits, locals, memarg, memsec, memtype, module, mut, name, section, start, startsec, table, tableidx, tablesec, tabletype, typeidx, typesec, u32, valtype, vec, };

package/dist/index.js

@@ -1,309 +0,0 @@
-const SECTION_ID_TYPE = 1;
-const SECTION_ID_IMPORT = 2;
-const SECTION_ID_FUNCTION = 3;
-const SECTION_ID_TABLE = 4;
-const SECTION_ID_MEMORY = 5;
-const SECTION_ID_GLOBAL = 6;
-const SECTION_ID_EXPORT = 7;
-const SECTION_ID_START = 8;
-const SECTION_ID_ELEMENT = 9;
-const SECTION_ID_CODE = 10;
-const SECTION_ID_DATA = 11;
-const TYPE_FUNCTION = 0x60;
-function stringToBytes(s) {
-    const bytes = new TextEncoder().encode(s);
-    return Array.from(bytes);
-}
-function int32ToBytes(v) {
-    // prettier-ignore
-    return [
-        v & 0xff,
-        (v >> 8) & 0xff,
-        (v >> 16) & 0xff,
-        (v >> 24) & 0xff,
-    ];
-}
-function magic() {
-    // [0x00, 0x61, 0x73, 0x6d]
-    return stringToBytes("\0asm");
-}
-function version() {
-    // [0x01, 0x00, 0x00, 0x00]
-    return int32ToBytes(1);
-}
-var valtype;
-(function (valtype) {
-    valtype[valtype["i32"] = 127] = "i32";
-    valtype[valtype["i64"] = 126] = "i64";
-    valtype[valtype["f32"] = 125] = "f32";
-    valtype[valtype["f64"] = 124] = "f64";
-})(valtype || (valtype = {}));
-// t: valtype
-function blocktype(t) {
-    return t ?? 0x40;
-}
-function vec(elements) {
-    return [u32(elements.length), ...elements];
-}
-function section(id, contents) {
-    const sizeInBytes = contents.flat(Infinity).length;
-    return [id, u32(sizeInBytes), contents];
-}
-function functype(paramTypes, resultTypes) {
-    return [TYPE_FUNCTION, vec(paramTypes), vec(resultTypes)];
-}
-function typesec(functypes) {
-    return section(SECTION_ID_TYPE, vec(functypes));
-}
-const typeidx = u32;
-function funcsec(typeidxs) {
-    return section(SECTION_ID_FUNCTION, vec(typeidxs));
-}
-function code(func) {
-    const sizeInBytes = func.flat(Infinity).length;
-    return [u32(sizeInBytes), func];
-}
-function func(locals, body) {
-    return [vec(locals), body];
-}
-function codesec(codes) {
-    return section(SECTION_ID_CODE, vec(codes));
-}
-function name(s) {
-    return vec(stringToBytes(s));
-}
-function export_(nm, exportdesc) {
-    return [name(nm), exportdesc];
-}
-function exportsec(exports) {
-    return section(SECTION_ID_EXPORT, vec(exports));
-}
-const funcidx = u32;
-const exportdesc = {
-    func(idx) {
-        return [0x00, funcidx(idx)];
-    },
-    table(idx) {
-        return [0x01, tableidx(idx)];
-    },
-    mem(idx) {
-        return [0x02, memidx(idx)];
-    },
-    global(idx) {
-        return [0x03, globalidx(idx)];
-    },
-};
-function module(sections) {
-    return [magic(), version(), sections];
-}
-const instr = {
-    unreachable: 0x00,
-    nop: 0x01,
-    block: 0x02,
-    loop: 0x03,
-    if: 0x04,
-    else: 0x05,
-    end: 0x0b,
-    br: 0x0c,
-    br_if: 0x0d,
-    br_table: 0x0e,
-    return: 0x0f,
-    call: 0x10,
-    call_indirect: 0x11,
-    drop: 0x1a,
-    select: 0x1b,
-    local: {
-        get: 0x20,
-        set: 0x21,
-        tee: 0x22,
-    },
-    global: {
-        get: 0x23,
-        set: 0x24,
-        tee: 0x25,
-    },
-    memory: {
-        size: 0x3f,
-        grow: 0x40,
-    },
-    i32: {
-        load: 0x28,
-        const: 0x41,
-        eqz: 0x45,
-        eq: 0x46,
-        ne: 0x47,
-        lt_s: 0x48,
-        lt_u: 0x49,
-        gt_s: 0x4a,
-        gt_u: 0x4b,
-        le_s: 0x4c,
-        le_u: 0x4d,
-        ge_s: 0x4e,
-        ge_u: 0x4f,
-        add: 0x6a,
-        sub: 0x6b,
-        mul: 0x6c,
-    },
-    i64: {
-        store32: 0x3e,
-        const: 0x42,
-        add: 0x7c,
-        sub: 0x7d,
-        mul: 0x7e,
-    },
-    f32: {
-        const: 0x43,
-        add: 0x92,
-        sub: 0x93,
-        mul: 0x94,
-        div: 0x95,
-    },
-    f64: {
-        load: 0x2b,
-        store: 0x39,
-        const: 0x44,
-        add: 0xa0,
-        sub: 0xa1,
-        mul: 0xa2,
-        div: 0xa3,
-        reinterpret_i64: 0xbf,
-    },
-};
-const SEVEN_BIT_MASK_BIG_INT = 127n;
-const CONTINUATION_BIT = 0b10000000;
-function u32(v) {
-    let val = BigInt(v);
-    let more = true;
-    const r = [];
-    while (more) {
-        const b = Number(val & SEVEN_BIT_MASK_BIG_INT);
-        val = val >> 7n;
-        more = val !== 0n;
-        if (more) {
-            r.push(b | CONTINUATION_BIT);
-        }
-        else {
-            r.push(b);
-        }
-    }
-    return r;
-}
-function i32(v) {
-    let val = BigInt(v);
-    const r = [];
-    let more = true;
-    while (more) {
-        const b = Number(val & 127n);
-        const signBitSet = !!(b & 0x40);
-        val = val >> 7n;
-        if ((val === 0n && !signBitSet) || (val === -1n && signBitSet)) {
-            more = false;
-            r.push(b);
-        }
-        else {
-            r.push(b | CONTINUATION_BIT);
-        }
-    }
-    return r;
-}
-function f64(v) {
-    var buf = new ArrayBuffer(8);
-    new Float64Array(buf)[0] = v;
-    return Array.from(new Uint8Array(buf));
-}
-function locals(n, type) {
-    return [u32(n), type];
-}
-// mod:name  nm:name  d:importdesc
-function import_(mod, nm, d) {
-    return [name(mod), name(nm), d];
-}
-// im*:vec(import)
-function importsec(ims) {
-    return section(SECTION_ID_IMPORT, vec(ims));
-}
-const importdesc = {
-    // x:typeidx
-    func(x) {
-        return [0x00, x];
-    },
-    // tt:tabletype
-    table(tt) {
-        return [0x01, tt];
-    },
-    // mt:memtype
-    mem(mt) {
-        return [0x02, mt];
-    },
-    // gt:globaltype
-    global(gt) {
-        return [0x03, gt];
-    },
-};
-const memidx = u32;
-function memsec(mems) {
-    return section(SECTION_ID_MEMORY, vec(mems));
-}
-// lim:limits
-function memtype(limits) {
-    return limits;
-}
-const limits = {
-    min(n) {
-        return [0x00, u32(n)];
-    },
-    minmax(n, m) {
-        return [0x01, u32(n), u32(m)];
-    },
-};
-const globalidx = u32;
-const mut = {
-    const: 0x00,
-    var: 0x01,
-};
-// t:valtype  m:mut
-function globaltype(t, m) {
-    return [t, m];
-}
-// gt:globaltype  e:expr
-function global(gt, e) {
-    return [gt, e];
-}
-// glob*:vec(global)
-function globalsec(globs) {
-    return section(SECTION_ID_GLOBAL, vec(globs));
-}
-function tabletype(elemtype, limits) {
-    return [elemtype, limits];
-}
-function table(tabletype) {
-    return tabletype;
-}
-function tablesec(tables) {
-    return section(SECTION_ID_TABLE, vec(tables));
-}
-const elemtype = { funcref: 0x70 };
-const tableidx = u32;
-const start = funcidx;
-// st:start
-function startsec(st) {
-    return section(SECTION_ID_START, st);
-}
-// x:memidx  e:expr  b∗:vec(byte)
-function data(x, e, bs) {
-    return [x, e, vec(bs)];
-}
-function datasec(segs) {
-    return section(SECTION_ID_DATA, vec(segs));
-}
-// x:tableidx  e:expr  y∗:vec(funcidx)
-function elem(x, e, ys) {
-    return [x, e, vec(ys)];
-}
-function elemsec(segs) {
-    return section(SECTION_ID_ELEMENT, vec(segs));
-}
-function memarg(align, offset) {
-    return [u32(align), u32(offset)];
-}
-export { blocktype, code, codesec, data, datasec, elem, elemsec, elemtype, export_, exportdesc, exportsec, f64, func, funcidx, funcsec, functype, global, globalsec, globaltype, i32, import_, importdesc, importsec, instr, limits, locals, memarg, memsec, memtype, module, mut, name, section, start, startsec, table, tableidx, tablesec, tabletype, typeidx, typesec, u32, valtype, vec, };

package/index.ts

@@ -1,432 +0,0 @@
-const SECTION_ID_TYPE = 1;
-const SECTION_ID_IMPORT = 2;
-const SECTION_ID_FUNCTION = 3;
-const SECTION_ID_TABLE = 4;
-const SECTION_ID_MEMORY = 5;
-const SECTION_ID_GLOBAL = 6;
-const SECTION_ID_EXPORT = 7;
-const SECTION_ID_START = 8;
-const SECTION_ID_ELEMENT = 9;
-const SECTION_ID_CODE = 10;
-const SECTION_ID_DATA = 11;
-
-const TYPE_FUNCTION = 0x60;
-
-type BytecodeFragment = (number | BytecodeFragment)[];
-
-function stringToBytes(s: string): number[] {
-  const bytes = new TextEncoder().encode(s);
-  return Array.from(bytes);
-}
-
-function int32ToBytes(v: number): number[] {
-  // prettier-ignore
-  return [
-    v & 0xff,
-    (v >> 8) & 0xff,
-    (v >> 16) & 0xff,
-    (v >> 24) & 0xff,
-  ];
-}
-
-function magic(): number[] {
-  // [0x00, 0x61, 0x73, 0x6d]
-  return stringToBytes("\0asm");
-}
-
-function version(): number[] {
-  // [0x01, 0x00, 0x00, 0x00]
-  return int32ToBytes(1);
-}
-
-enum valtype {
-  i32 = 0x7f,
-  i64 = 0x7e,
-  f32 = 0x7d,
-  f64 = 0x7c,
-}
-
-// t: valtype
-function blocktype(t?: valtype): number {
-  return t ?? 0x40;
-}
-
-function vec<T extends BytecodeFragment>(elements: T): BytecodeFragment {
-  return [u32(elements.length), ...elements];
-}
-
-function section(id: number, contents: BytecodeFragment) {
-  const sizeInBytes = (contents as any[]).flat(Infinity).length;
-  return [id, u32(sizeInBytes), contents];
-}
-
-function functype(
-  paramTypes: valtype[],
-  resultTypes: valtype[],
-): BytecodeFragment {
-  return [TYPE_FUNCTION, vec(paramTypes), vec(resultTypes)];
-}
-
-function typesec(functypes: BytecodeFragment): BytecodeFragment {
-  return section(SECTION_ID_TYPE, vec(functypes));
-}
-
-const typeidx = u32;
-
-function funcsec(typeidxs: BytecodeFragment): BytecodeFragment {
-  return section(SECTION_ID_FUNCTION, vec(typeidxs));
-}
-
-function code(func: BytecodeFragment): BytecodeFragment {
-  const sizeInBytes = (func as any[]).flat(Infinity).length;
-  return [u32(sizeInBytes), func];
-}
-
-function func(
-  locals: BytecodeFragment,
-  body: BytecodeFragment,
-): BytecodeFragment {
-  return [vec(locals), body];
-}
-
-function codesec(codes: BytecodeFragment): BytecodeFragment {
-  return section(SECTION_ID_CODE, vec(codes));
-}
-
-function name(s: string): BytecodeFragment {
-  return vec(stringToBytes(s));
-}
-
-function export_(nm: string, exportdesc: BytecodeFragment): BytecodeFragment {
-  return [name(nm), exportdesc];
-}
-
-function exportsec(exports: BytecodeFragment): BytecodeFragment {
-  return section(SECTION_ID_EXPORT, vec(exports));
-}
-
-const funcidx = u32;
-
-const exportdesc = {
-  func(idx: number): BytecodeFragment {
-    return [0x00, funcidx(idx)];
-  },
-  table(idx: number): BytecodeFragment {
-    return [0x01, tableidx(idx)];
-  },
-  mem(idx: number): BytecodeFragment {
-    return [0x02, memidx(idx)];
-  },
-  global(idx: number): BytecodeFragment {
-    return [0x03, globalidx(idx)];
-  },
-};
-
-function module(sections): BytecodeFragment {
-  return [magic(), version(), sections];
-}
-
-const instr = {
-  unreachable: 0x00,
-  nop: 0x01,
-  block: 0x02,
-  loop: 0x03,
-  if: 0x04,
-  else: 0x05,
-  end: 0x0b,
-  br: 0x0c,
-  br_if: 0x0d,
-  br_table: 0x0e,
-  return: 0x0f,
-  call: 0x10,
-  call_indirect: 0x11,
-  drop: 0x1a,
-  select: 0x1b,
-
-  local: {
-    get: 0x20,
-    set: 0x21,
-    tee: 0x22,
-  },
-  global: {
-    get: 0x23,
-    set: 0x24,
-    tee: 0x25,
-  },
-  memory: {
-    size: 0x3f,
-    grow: 0x40,
-  },
-
-  i32: {
-    load: 0x28,
-    const: 0x41,
-    eqz: 0x45,
-    eq: 0x46,
-    ne: 0x47,
-    lt_s: 0x48,
-    lt_u: 0x49,
-    gt_s: 0x4a,
-    gt_u: 0x4b,
-    le_s: 0x4c,
-    le_u: 0x4d,
-    ge_s: 0x4e,
-    ge_u: 0x4f,
-    add: 0x6a,
-    sub: 0x6b,
-    mul: 0x6c,
-  },
-  i64: {
-    store32: 0x3e,
-    const: 0x42,
-    add: 0x7c,
-    sub: 0x7d,
-    mul: 0x7e,
-  },
-  f32: {
-    const: 0x43,
-    add: 0x92,
-    sub: 0x93,
-    mul: 0x94,
-    div: 0x95,
-  },
-  f64: {
-    load: 0x2b,
-    store: 0x39,
-    const: 0x44,
-    add: 0xa0,
-    sub: 0xa1,
-    mul: 0xa2,
-    div: 0xa3,
-    reinterpret_i64: 0xbf,
-  },
-};
-
-const SEVEN_BIT_MASK_BIG_INT = 0b01111111n;
-const CONTINUATION_BIT = 0b10000000;
-
-function u32(v: number | bigint): number[] {
-  let val = BigInt(v);
-  let more = true;
-  const r = [];
-
-  while (more) {
-    const b = Number(val & SEVEN_BIT_MASK_BIG_INT);
-    val = val >> 7n;
-    more = val !== 0n;
-    if (more) {
-      r.push(b | CONTINUATION_BIT);
-    } else {
-      r.push(b);
-    }
-  }
-  return r;
-}
-
-function i32(v: number | bigint): number[] {
-  let val = BigInt(v);
-  const r = [];
-
-  let more = true;
-  while (more) {
-    const b = Number(val & 0b01111111n);
-    const signBitSet = !!(b & 0x40);
-
-    val = val >> 7n;
-
-    if ((val === 0n && !signBitSet) || (val === -1n && signBitSet)) {
-      more = false;
-      r.push(b);
-    } else {
-      r.push(b | CONTINUATION_BIT);
-    }
-  }
-
-  return r;
-}
-
-function f64(v: number): number[] {
-  var buf = new ArrayBuffer(8);
-  new Float64Array(buf)[0] = v;
-  return Array.from(new Uint8Array(buf));
-}
-
-function locals(n: number, type: valtype): BytecodeFragment {
-  return [u32(n), type];
-}
-
-// mod:name  nm:name  d:importdesc
-function import_(
-  mod: string,
-  nm: string,
-  d: BytecodeFragment,
-): BytecodeFragment {
-  return [name(mod), name(nm), d];
-}
-
-// im*:vec(import)
-function importsec(ims: BytecodeFragment): BytecodeFragment {
-  return section(SECTION_ID_IMPORT, vec(ims));
-}
-
-const importdesc = {
-  // x:typeidx
-  func(x: BytecodeFragment): BytecodeFragment {
-    return [0x00, x];
-  },
-  // tt:tabletype
-  table(tt: BytecodeFragment): BytecodeFragment {
-    return [0x01, tt];
-  },
-  // mt:memtype
-  mem(mt: BytecodeFragment): BytecodeFragment {
-    return [0x02, mt];
-  },
-  // gt:globaltype
-  global(gt: BytecodeFragment): BytecodeFragment {
-    return [0x03, gt];
-  },
-};
-
-const memidx = u32;
-
-function memsec(mems: BytecodeFragment[]) {
-  return section(SECTION_ID_MEMORY, vec(mems));
-}
-
-// lim:limits
-function memtype(limits: BytecodeFragment) {
-  return limits;
-}
-
-const limits = {
-  min(n: number) {
-    return [0x00, u32(n)];
-  },
-  minmax(n: number, m: number) {
-    return [0x01, u32(n), u32(m)];
-  },
-};
-
-const globalidx = u32;
-
-const mut = {
-  const: 0x00,
-  var: 0x01,
-};
-
-// t:valtype  m:mut
-function globaltype(t, m) {
-  return [t, m];
-}
-
-// gt:globaltype  e:expr
-function global(gt, e) {
-  return [gt, e];
-}
-
-// glob*:vec(global)
-function globalsec(globs: BytecodeFragment[]) {
-  return section(SECTION_ID_GLOBAL, vec(globs));
-}
-
-function tabletype(elemtype: number, limits: BytecodeFragment) {
-  return [elemtype, limits];
-}
-
-function table(tabletype: BytecodeFragment) {
-  return tabletype;
-}
-
-function tablesec(tables: BytecodeFragment[]) {
-  return section(SECTION_ID_TABLE, vec(tables));
-}
-
-const elemtype = { funcref: 0x70 };
-
-const tableidx = u32;
-
-const start = funcidx;
-
-// st:start
-function startsec(st: BytecodeFragment) {
-  return section(SECTION_ID_START, st);
-}
-
-// x:memidx  e:expr  b∗:vec(byte)
-function data(
-  x: BytecodeFragment,
-  e: BytecodeFragment,
-  bs: BytecodeFragment[],
-) {
-  return [x, e, vec(bs)];
-}
-
-function datasec(segs: BytecodeFragment[]) {
-  return section(SECTION_ID_DATA, vec(segs));
-}
-
-// x:tableidx  e:expr  y∗:vec(funcidx)
-function elem(
-  x: BytecodeFragment,
-  e: BytecodeFragment,
-  ys: BytecodeFragment[],
-) {
-  return [x, e, vec(ys)];
-}
-
-function elemsec(segs: BytecodeFragment[]) {
-  return section(SECTION_ID_ELEMENT, vec(segs));
-}
-
-function memarg(align: number, offset: number) {
-  return [u32(align), u32(offset)];
-}
-
-export {
-  blocktype,
-  BytecodeFragment,
-  code,
-  codesec,
-  data,
-  datasec,
-  elem,
-  elemsec,
-  elemtype,
-  export_,
-  exportdesc,
-  exportsec,
-  f64,
-  func,
-  funcidx,
-  funcsec,
-  functype,
-  global,
-  globalsec,
-  globaltype,
-  i32,
-  import_,
-  importdesc,
-  importsec,
-  instr,
-  limits,
-  locals,
-  memarg,
-  memsec,
-  memtype,
-  module,
-  mut,
-  name,
-  section,
-  start,
-  startsec,
-  table,
-  tableidx,
-  tablesec,
-  tabletype,
-  typeidx,
-  typesec,
-  u32,
-  valtype,
-  vec,
-};

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "files": ["index.ts"],
-  "compilerOptions": {
-    "outDir": "dist",
-    "target": "es2020",
-    "declaration": true
-  }
-}