@wasmgroundup/emit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 WebAssembly from the Ground Up
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# emit

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+type BytecodeFragment = (number | BytecodeFragment)[];
+declare enum valtype {
+    i32 = 127,
+    i64 = 126,
+    f32 = 125,
+    f64 = 124
+}
+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;
+};
+declare function module(sections: any): BytecodeFragment;
+declare const instr: {
+    nop: number;
+    end: number;
+    i32: {
+        const: number;
+        add: number;
+        sub: number;
+    };
+    i64: {
+        const: number;
+    };
+};
+declare function u32(v: number | bigint): number[];
+declare function i32(v: number | bigint): number[];
+declare function locals(n: number, type: valtype): BytecodeFragment;
+export { code, codesec, export_, exportdesc, exportsec, func, funcidx, funcsec, functype, i32, instr, locals, module, name, section, typeidx, typesec, valtype, vec, };

package/dist/index.js

@@ -0,0 +1,136 @@
+const SECTION_ID_TYPE = 1;
+const SECTION_ID_FUNCTION = 3;
+const SECTION_ID_EXPORT = 7;
+const SECTION_ID_CODE = 10;
+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 = {}));
+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)];
+    },
+};
+function module(sections) {
+    return [magic(), version(), sections];
+}
+var numtype;
+(function (numtype) {
+    numtype[numtype["i32"] = 127] = "i32";
+})(numtype || (numtype = {}));
+const instr = {
+    nop: 0x01,
+    end: 0x0b,
+    i32: {
+        const: 0x41,
+        add: 0x6a,
+        sub: 0x6b,
+    },
+    i64: {
+        const: 0x42,
+    },
+};
+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;
+}
+///! START i32-v1 #priv #api #dedent
+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 locals(n, type) {
+    return [u32(n), type];
+}
+export { code, codesec, export_, exportdesc, exportsec, func, funcidx, funcsec, functype, i32, instr, locals, module, name, section, typeidx, typesec, valtype, vec, };

package/index.test.ts

@@ -0,0 +1,42 @@
+import { expect, test } from "bun:test";
+
+import {
+  module,
+  typesec,
+  functype,
+  valtype,
+  funcsec,
+  typeidx,
+  exportsec,
+  export_,
+  exportdesc,
+  codesec,
+  code,
+  func,
+  locals,
+  instr,
+} from "./index";
+
+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 Uint8Array.from(mod.flat(Infinity));
+  };
+  const runMain = async (bytes, args) => {
+    const { instance } = await WebAssembly.instantiate(bytes);
+    return instance.exports.main(...args);
+  };
+
+  expect(await runMain(makeModule([], [], [instr.end]), [])).toBe(undefined);
+  expect(
+    await runMain(
+      makeModule([], [valtype.i32], [instr.i32.const, 1, instr.end]),
+      [],
+    ),
+  ).toBe(1);
+});

package/index.ts

@@ -0,0 +1,194 @@
+const SECTION_ID_TYPE = 1;
+const SECTION_ID_FUNCTION = 3;
+const SECTION_ID_EXPORT = 7;
+const SECTION_ID_CODE = 10;
+
+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,
+}
+
+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)];
+  },
+};
+
+function module(sections): BytecodeFragment {
+  return [magic(), version(), sections];
+}
+
+enum numtype {
+  i32 = 0x7f,
+}
+
+const instr = {
+  nop: 0x01,
+  end: 0x0b,
+
+  i32: {
+    const: 0x41,
+    add: 0x6a,
+    sub: 0x6b,
+  },
+  i64: {
+    const: 0x42,
+  },
+};
+
+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;
+}
+
+///! START i32-v1 #priv #api #dedent
+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 locals(n: number, type: valtype): BytecodeFragment {
+  return [u32(n), type];
+}
+
+export {
+  code,
+  codesec,
+  export_,
+  exportdesc,
+  exportsec,
+  func,
+  funcidx,
+  funcsec,
+  functype,
+  i32,
+  instr,
+  locals,
+  module,
+  name,
+  section,
+  typeidx,
+  typesec,
+  valtype,
+  vec,
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@wasmgroundup/emit",
+  "description": "A library for creating binary-encoded WebAssembly modules",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wasmgroundup/emit.git"
+  },
+  "keywords": [
+    "wasm",
+    "webassembly"
+  ],
+  "author": "Mariano Guerra & Patrick Dubroy <hello@wasmgroundup.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/wasmgroundup/emit/issues"
+  },
+  "homepage": "https://github.com/wasmgroundup/emit#readme",
+  "scripts": {
+    "check": "tsc --noEmit",
+    "format": "prettier --write .",
+    "prepublish": "tsc"
+  },
+  "dependencies": {
+    "prettier": "^3.0.3"
+  },
+  "devDependencies": {
+    "typescript": "^5.2.2"
+  }
+}

package/tsconfig.json

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