watr 2.2.5 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watr",
-  "version": "2.2.5",
+  "version": "2.3.0",
   "description": "Ligth & fast WAT compiler",
   "main": "watr.js",
   "exports": {
@@ -39,8 +39,9 @@
   },
   "homepage": "https://github.com/audio-lab/watr#readme",
   "devDependencies": {
-    "tst": "^7.1.1",
+    "tst": "^7.3.0",
     "wabt": "^1.0.28",
+    "wassemble": "^0.0.2",
     "wat-compiler": "^1.0.0"
   }
 }

package/readme.md

@@ -1,44 +1,26 @@
-# watr [![test](https://github.com/audio-lab/watr/actions/workflows/test.js.yml/badge.svg)](https://github.com/audio-lab/watr/actions/workflows/test.js.yml) [![npm bundle size](https://img.shields.io/bundlephobia/minzip/watr/latest?color=brightgreen&label=gzip)](https://bundlephobia.com/package/watr)
+# watr [![test](https://github.com/audio-lab/watr/actions/workflows/test.js.yml/badge.svg)](https://github.com/audio-lab/watr/actions/workflows/test.js.yml) [![npm bundle size](https://img.shields.io/bundlephobia/minzip/watr/latest?color=brightgreen&label=gzip)](https://bundlephobia.com/package/watr) [![npm](https://img.shields.io/npm/v/watr?color=red)](https://npmjs.org/watr)
 
-Bare minimum wasm text compiler & formatter, light & fast alternative for [wat2wasm](https://github.com/AssemblyScript/wabt.js).<br/>
+Bare minimum wasm text compiler/formatter.<br/>
+A light & fast alternative to [wat2wasm](https://github.com/AssemblyScript/wabt.js).<br/>
 Useful for hi-level languages or dynamic (in-browser) compilation.<br>
 
 <!-- See [REPL](https://audio-lab.github.io/watr/repl.html).-->
 
 &nbsp; | Size (gzipped) | Performance (op/s)
----|---|---
+---|---|---|---
 watr | 3.8 kb | 6000
 [wat-compiler](https://github.com/stagas/wat-compiler) | 6 kb | 348
 [wabt](https://github.com/AssemblyScript/wabt.js) | 300 kb | 574
+[wassemble](https://github.com/wingo/wassemble) | ? kb | ?
 
 ## Usage
 
-```js
-import wat from 'watr'
-
-// compile text to binary
-const buffer = wat(`(func
-  (export "double") (param f64) (result f64)
-  (f64.mul (local.get 0) (f64.const 2))
-)`)
-
-// create instance
-const module = new WebAssembly.Module(buffer)
-const instance = new WebAssembly.Instance(module)
-
-// use API
-const {double} = instance.exports
-double(108) // 216
-```
-
-## API
-
 ### Compile
 
-Compiles wasm text or syntax tree into wasm binary.
+Compile wasm text or syntax tree into wasm binary.
 
 ```js
-import { compile } from 'watr'
+import compile from 'watr' // or `import { compile } from 'watr'`
 
 const buffer = compile(`(func (export "double")
   (param f64) (result f64)
@@ -99,10 +81,12 @@ parse(`(func (export "double") (param f64) (result f64) (f64.mul (local.get 0) (
 ## Status
 
 * [x] wasm core
-* [x] multiple values
-* [x] bulk memory ops (0 index)
-* [ ] func/ref types
-* [ ] multiple memories
+* [x] [multi-value](https://github.com/WebAssembly/spec/blob/master/proposals/multi-value/Overview.md)
+* [x] [bulk memory ops](https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md)
+* [x] [simd](https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md)
+* [ ] [multiple memories](https://github.com/WebAssembly/multi-memory/blob/master/proposals/multi-memory/Overview.md)
+* [ ] [func refs](https://github.com/WebAssembly/function-references/blob/main/proposals/function-references/Overview.md)
+* [ ] [gc](https://github.com/WebAssembly/gc)
 
 
 <!--
@@ -134,11 +118,4 @@ parse(`(func (export "double") (param f64) (result f64) (f64.mul (local.get 0) (
 * [leb128b](https://github.com/shmishtopher/wasm-LEB128/tree/master/esm)
 -->
 
-## Alternatives
-
-* [wabt](https://www.npmjs.com/package/wabt) − port of WABT for the web, de-facto standard.
-* [wat-compiler](https://www.npmjs.com/package/wat-compiler) − compact alternative for WABT, older brother of _watr_.
-* [wassemble](https://github.com/wingo/wassemble)
-* [web49](https://github.com/FastVM/Web49)
-
 <p align=center><a href="https://github.com/krsnzd/license/">🕉</a></p>

package/src/compile.js

@@ -1,8 +1,9 @@
-import { uleb, leb, bigleb, f64, f32 } from './util.js'
+import * as encode from './encode.js'
+import { uleb } from './encode.js'
 import { OP, SECTION, ALIGN, TYPE, KIND } from './const.js'
 import parse from './parse.js'
+import { err, TypedArray } from './util.js'
 
-const OP_END = 0xb, OP_I32_CONST = 0x41, OP_I64_CONST = 0x42, OP_F32_CONST = 0x43, OP_F64_CONST = 0x44, OP_SKIP = 0x6
 
 /**
  * Converts a WebAssembly Text Format (WAT) tree to a WebAssembly binary format (Wasm).
@@ -121,11 +122,38 @@ const build = {
 
       // NOTE: numeric comparison is faster than generic hash lookup
 
+      // v128s: (v128.load x) etc
+      // https://github.com/WebAssembly/simd/blob/master/proposals/simd/BinarySIMD.md
+      if (opCode >= 268) {
+        opCode -= 268
+        immed = [0xfd, ...uleb(opCode)]
+        // (v128.load)
+        if (opCode <= 0x0b) {
+          const o = consumeParams(args)
+          immed.push(Math.log2(o.align ?? ALIGN[op]), ...uleb(o.offset ?? 0))
+        }
+        // (v128.load_lane offset? align? idx)
+        else if (opCode >= 0x54 && opCode <= 0x5d) {
+          const o = consumeParams(args)
+          immed.push(Math.log2(o.align ?? ALIGN[op]), ...uleb(o.offset ?? 0))
+          // (v128.load_lane_zero)
+          if (opCode <= 0x5b) immed.push(...uleb(args.shift()))
+        }
+        // (v128.const i32x4), (i8x16.shuffle 0 1 ... 15 a b)
+        else if (opCode === 0x0c || opCode === 0x0d) {
+          immed.push(...consumeConst(op.split('.')[0], args))
+        }
+        // (i8x16.extract_lane_s 0 ...)
+        else if (opCode >= 0x15 && opCode <= 0x22) {
+          immed.push(...uleb(args.shift()))
+        }
+        opCode = null // ignore opcode
+      }
 
       // bulk memory: (memory.init) (memory.copy) etc
       // https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md#instruction-encoding
-      if (opCode >= 252) {
-        immed = [0xfc, opCode %= 252]
+      else if (opCode >= 252) {
+        immed = [0xfc, ...uleb(opCode -= 252)]
         // memory.init idx, memory.drop idx, table.init idx, table.drop idx
         if (!(opCode & 0b10)) immed.push(...uleb(args.shift()))
         else immed.push(0)
@@ -134,20 +162,19 @@ const build = {
         opCode = null // ignore opcode
       }
 
-      // binary/unary - just consume immed
-      else if (opCode >= 69) { }
+      // binary/unary (i32.add a b) - no immed
+      else if (opCode >= 0x45) { }
 
-      // (i32.store align=n offset=m at value)
+      // (i32.store align=n offset=m at value) etc
       else if (opCode >= 40 && opCode <= 62) {
         // FIXME: figure out point in Math.log2 aligns
-        let o = { align: ALIGN[op], offset: 0 }, param
-        while (args[0]?.includes('=')) param = args.shift().split('='), o[param[0]] = Number(param[1])
-        immed = [Math.log2(o.align), ...uleb(o.offset)]
+        let o = consumeParams(args)
+        immed = [Math.log2(o.align ?? ALIGN[op]), ...uleb(o.offset ?? 0)]
       }
 
-      // (i32.const 123)
-      else if (opCode >= 65 && opCode <= 68) {
-        immed = (opCode == 65 ? leb : opCode == 66 ? bigleb : opCode == 67 ? f32 : f64)(args.shift())
+      // (i32.const 123), (f32.const 123.45) etc
+      else if (opCode >= 0x41 && opCode <= 0x44) {
+        immed = encode[op.split('.')[0]](args.shift())
       }
 
       // (local.get $id), (local.tee $id x)
@@ -156,7 +183,7 @@ const build = {
       }
 
       // (global.get id), (global.set id)
-      else if (opCode == 35 || opCode == 36) {
+      else if (opCode == 0x23 || opCode == 36) {
         immed = uleb(args[0]?.[0] === '$' ? ctx.global[args.shift()] : args.shift())
       }
 
@@ -264,7 +291,7 @@ const build = {
     return () => {
       const bytes = []
       while (body.length) consume(body, bytes)
-      ctx.code.push([...uleb(bytes.length + 2 + locTypes.length), ...uleb(locTypes.length >> 1), ...locTypes, ...bytes, OP_END])
+      ctx.code.push([...uleb(bytes.length + 2 + locTypes.length), ...uleb(locTypes.length >> 1), ...locTypes, ...bytes, 0x0b])
     }
   },
 
@@ -284,7 +311,7 @@ const build = {
     let name = args[0][0] === '$' && args.shift()
     if (name) ctx.global[name] = ctx.global.length
     let [type, init] = args, mut = type[0] === 'mut' ? 1 : 0
-    ctx.global.push([TYPE[mut ? type[1] : type], mut, ...iinit(init)])
+    ctx.global.push([TYPE[mut ? type[1] : type], mut, ...initGlobal(init)])
   },
 
   // (table 1 2? funcref)
@@ -299,7 +326,7 @@ const build = {
   // (elem (i32.const 0) $f1 $f2), (elem (global.get 0) $f1 $f2)
   elem([, offset, ...elems], ctx) {
     const tableIdx = 0 // FIXME: table index can be defined
-    ctx.elem.push([tableIdx, ...iinit(offset, ctx), ...uleb(elems.length), ...elems.flatMap(el => uleb(el[0] === '$' ? ctx.func[el] : el))])
+    ctx.elem.push([tableIdx, ...initGlobal(offset, ctx), ...uleb(elems.length), ...elems.flatMap(el => uleb(el[0] === '$' ? ctx.func[el] : el))])
   },
 
   //  (export "name" (kind $name|idx))
@@ -341,9 +368,18 @@ const build = {
   },
 
   // (data (i32.const 0) "\aa" "\bb"?)
-  data([, offset, ...inits], ctx) {
-    // FIXME: first is mem index
-    ctx.data.push([0, ...iinit(offset, ctx), ...str(inits.map(i => i[0] === '"' ? i.slice(1, -1) : i).join(''))])
+  // (data (offset (i32.const 0)) (memory ref) "\aa" "\bb"?)
+  // (data (global.get $x) "\aa" "\bb"?)
+  data([, ...inits], ctx) {
+    let offset, mem
+
+    if (inits[0]?.[0] === 'offset') [, offset] = inits.shift()
+    if (inits[0]?.[0] === 'memory') [, mem] = inits.shift()
+    if (inits[0]?.[0] === 'offset') [, offset] = inits.shift()
+    if (!offset && !mem) offset = inits.shift()
+    if (!offset) offset = ['i32.const', 0]
+
+    ctx.data.push([0, ...initGlobal(offset, ctx), ...str(inits.map(i => i[0] === '"' ? i.slice(1, -1) : i).join(''))])
   },
 
   // (start $main)
@@ -352,11 +388,33 @@ const build = {
   }
 }
 
-// (i32.const 0) - instantiation time initializer
-const iinit = ([op, literal], ctx) => op[0] === 'f' ?
-  [op[1] === '3' ? OP_F32_CONST : OP_F64_CONST, ...(op[1] === '3' ? f32 : f64)(literal), OP_END] :
-  [op[1] === '3' ? OP_I32_CONST : OP_I64_CONST, ...(op[1] === '3' ? leb : bigleb)(literal[0] === '$' ? ctx.global[literal] : literal), OP_END]
+// (i32.const 0), (global.get idx) - instantiation time initializer
+const initGlobal = ([op, literal, ...args], ctx) => {
+  if (op === 'global.get') return [0x23, ...uleb(literal[0] === '$' ? ctx.global[literal] : literal), 0x0b]
+  const [type] = op.split('.')
+  // (v128.const i32x4 1 2 3 4)
+  return [...(type === 'v128' ? [0xfd, 0x0c] : [0x41 + ['i32', 'i64', 'f32', 'f64'].indexOf(type)]), ...consumeConst(type, [literal, ...args]), 0x0b]
+}
+
+// consume cost, no op type
+const consumeConst = (type, args) => {
+  // (v128.const i32x4 1 2 3 4), (i8x16.shuffle 1 2 ... 15)
+  if (type === 'v128' || type === 'i8x16') {
+    let [t, n] = (type === 'v128' ? args.shift() : type).split('x'),
+      bytes = new Uint8Array(16),
+      arr = new TypedArray[t](bytes.buffer)
+
+    for (let i = 0; i < n; i++) {
+      arr[i] = encode[t].parse(args.shift())
+    }
 
+    return bytes
+  }
+  // (i32.const 1)
+  return encode[type](args[0])
+}
+
+// escape codes
 const escape = { n: 10, r: 13, t: 9, v: 1, '\\': 92 }
 
 // build string binary
@@ -402,4 +460,9 @@ const consumeType = (nodes, ctx) => {
   return [idx, params, result]
 }
 
-const err = text => { throw Error(text) }
+// consume align/offset/etc params
+const consumeParams = (args) => {
+  let params = {}, param
+  while (args[0]?.includes('=')) param = args.shift().split('='), params[param[0]] = Number(param[1])
+  return params
+}

package/src/const.js

@@ -1,5 +1,6 @@
 // ref: https://github.com/stagas/wat-compiler/blob/main/lib/const.js
 // NOTE: squashing into a string doesn't save up gzipped size
+// FIXME: object would allow faster lookup and number of immediates, which would allow reducing size of compile fn
 export const OP = [
   'unreachable', 'nop', 'block', 'loop', 'if', 'else', 'then', , , , ,
   'end', 'br', 'br_if', 'br_table', 'return', 'call', 'call_indirect', , , , , , , , ,
@@ -26,10 +27,17 @@ export const OP = [
   'f32.convert_i32_s', 'f32.convert_i32_u', 'f32.convert_i64_s', 'f32.convert_i64_u', 'f32.demote_f64',
   'f64.convert_i32_s', 'f64.convert_i32_u', 'f64.convert_i64_s', 'f64.convert_i64_u', 'f64.promote_f32',
   'i32.reinterpret_f32', 'i64.reinterpret_f64', 'f32.reinterpret_i32', 'f64.reinterpret_i64', , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
-  'memory.init', 'data.drop', 'memory.copy', 'memory.fill', 'table.init', 'elem.drop', 'table.copy'
+  'memory.init', 'data.drop', 'memory.copy', 'memory.fill', 'table.init', 'elem.drop', 'table.copy', ,
+
+  // ref: https://github.com/WebAssembly/simd/blob/master/proposals/simd/BinarySIMD.md
+  "v128.load", "v128.load8x8_s", "v128.load8x8_u", "v128.load16x4_s", "v128.load16x4_u", "v128.load32x2_s", "v128.load32x2_u", "v128.load8_splat", "v128.load16_splat", "v128.load32_splat", "v128.load64_splat", "v128.store", "v128.const", "i8x16.shuffle",
+  "i8x16.swizzle", "i8x16.splat", "i16x8.splat", "i32x4.splat", "i64x2.splat", "f32x4.splat", "f64x2.splat", "i8x16.extract_lane_s", "i8x16.extract_lane_u", "i8x16.replace_lane", "i16x8.extract_lane_s", "i16x8.extract_lane_u", "i16x8.replace_lane", "i32x4.extract_lane", "i32x4.replace_lane", "i64x2.extract_lane", "i64x2.replace_lane", "f32x4.extract_lane", "f32x4.replace_lane", "f64x2.extract_lane", "f64x2.replace_lane",
+  "i8x16.eq", "i8x16.ne", "i8x16.lt_s", "i8x16.lt_u", "i8x16.gt_s", "i8x16.gt_u", "i8x16.le_s", "i8x16.le_u", "i8x16.ge_s", "i8x16.ge_u", "i16x8.eq", "i16x8.ne", "i16x8.lt_s", "i16x8.lt_u", "i16x8.gt_s", "i16x8.gt_u", "i16x8.le_s", "i16x8.le_u", "i16x8.ge_s", "i16x8.ge_u", "i32x4.eq", "i32x4.ne", "i32x4.lt_s", "i32x4.lt_u", "i32x4.gt_s", "i32x4.gt_u", "i32x4.le_s", "i32x4.le_u", "i32x4.ge_s", "i32x4.ge_u", "f32x4.eq", "f32x4.ne", "f32x4.lt", "f32x4.gt", "f32x4.le", "f32x4.ge", "f64x2.eq", "f64x2.ne", "f64x2.lt", "f64x2.gt", "f64x2.le", "f64x2.ge", "v128.not", "v128.and", "v128.andnot", "v128.or", "v128.xor", "v128.bitselect", "v128.any_true",
+  "v128.load8_lane", "v128.load16_lane", "v128.load32_lane", "v128.load64_lane", "v128.store8_lane", "v128.store16_lane", "v128.store32_lane", "v128.store64_lane", "v128.load32_zero", "v128.load64_zero", "f32x4.demote_f64x2_zero", "f64x2.promote_low_f32x4",
+  "i8x16.abs", "i8x16.neg", "i8x16.popcnt", "i8x16.all_true", "i8x16.bitmask", "i8x16.narrow_i16x8_s", "i8x16.narrow_i16x8_u", "f32x4.ceil", "f32x4.floor", "f32x4.trunc", "f32x4.nearest", "i8x16.shl", "i8x16.shr_s", "i8x16.shr_u", "i8x16.add", "i8x16.add_sat_s", "i8x16.add_sat_u", "i8x16.sub", "i8x16.sub_sat_s", "i8x16.sub_sat_u", "f64x2.ceil", "f64x2.floor", "i8x16.min_s", "i8x16.min_u", "i8x16.max_s", "i8x16.max_u", "f64x2.trunc", "i8x16.avgr_u", "i16x8.extadd_pairwise_i8x16_s", "i16x8.extadd_pairwise_i8x16_u", "i32x4.extadd_pairwise_i16x8_s", "i32x4.extadd_pairwise_i16x8_u", "i16x8.abs", "i16x8.neg", "i16x8.q15mulr_sat_s", "i16x8.all_true", "i16x8.bitmask", "i16x8.narrow_i32x4_s", "i16x8.narrow_i32x4_u", "i16x8.extend_low_i8x16_s", "i16x8.extend_high_i8x16_s", "i16x8.extend_low_i8x16_u", "i16x8.extend_high_i8x16_u", "i16x8.shl", "i16x8.shr_s", "i16x8.shr_u", "i16x8.add", "i16x8.add_sat_s", "i16x8.add_sat_u", "i16x8.sub", "i16x8.sub_sat_s", "i16x8.sub_sat_u", "f64x2.nearest", "i16x8.mul", "i16x8.min_s", "i16x8.min_u", "i16x8.max_s", "i16x8.max_u", , "i16x8.avgr_u", "i16x8.extmul_low_i8x16_s", "i16x8.extmul_high_i8x16_s", "i16x8.extmul_low_i8x16_u", "i16x8.extmul_high_i8x16_u", "i32x4.abs", "i32x4.neg", , "i32x4.all_true", "i32x4.bitmask", , , "i32x4.extend_low_i16x8_s", "i32x4.extend_high_i16x8_s", "i32x4.extend_low_i16x8_u", "i32x4.extend_high_i16x8_u", "i32x4.shl", "i32x4.shr_s", "i32x4.shr_u", "i32x4.add", , , "i32x4.sub", , , , "i32x4.mul", "i32x4.min_s", "i32x4.min_u", "i32x4.max_s", "i32x4.max_u", "i32x4.dot_i16x8_s", , "i32x4.extmul_low_i16x8_s", "i32x4.extmul_high_i16x8_s", "i32x4.extmul_low_i16x8_u", "i32x4.extmul_high_i16x8_u", "i64x2.abs", "i64x2.neg", , "i64x2.all_true", "i64x2.bitmask", , , "i64x2.extend_low_i32x4_s", "i64x2.extend_high_i32x4_s", "i64x2.extend_low_i32x4_u", "i64x2.extend_high_i32x4_u", "i64x2.shl", "i64x2.shr_s", "i64x2.shr_u", "i64x2.add", , , "i64x2.sub", , , , "i64x2.mul", "i64x2.eq", "i64x2.ne", "i64x2.lt_s", "i64x2.gt_s", "i64x2.le_s", "i64x2.ge_s", "i64x2.extmul_low_i32x4_s", "i64x2.extmul_high_i32x4_s", "i64x2.extmul_low_i32x4_u", "i64x2.extmul_high_i32x4_u", "f32x4.abs", "f32x4.neg", , "f32x4.sqrt", "f32x4.add", "f32x4.sub", "f32x4.mul", "f32x4.div", "f32x4.min", "f32x4.max", "f32x4.pmin", "f32x4.pmax", "f64x2.abs", "f64x2.neg", , "f64x2.sqrt", "f64x2.add", "f64x2.sub", "f64x2.mul", "f64x2.div", "f64x2.min", "f64x2.max", "f64x2.pmin", "f64x2.pmax", "i32x4.trunc_sat_f32x4_s", "i32x4.trunc_sat_f32x4_u", "f32x4.convert_i32x4_s", "f32x4.convert_i32x4_u", "i32x4.trunc_sat_f64x2_s_zero", "i32x4.trunc_sat_f64x2_u_zero", "f64x2.convert_low_i32x4_s", "f64x2.convert_low_i32x4_u"
 ],
   SECTION = { type: 1, import: 2, func: 3, table: 4, memory: 5, global: 6, export: 7, start: 8, elem: 9, code: 10, data: 11 },
-  TYPE = { i32: 0x7f, i64: 0x7e, f32: 0x7d, f64: 0x7c, void: 0x40, func: 0x60, funcref: 0x70 },
+  TYPE = { i32: 0x7f, i64: 0x7e, f32: 0x7d, f64: 0x7c, void: 0x40, func: 0x60, funcref: 0x70, v128: 0x7B },
   KIND = { func: 0, table: 1, memory: 2, global: 3 },
   ALIGN = {
     'i32.load': 4, 'i64.load': 8, 'f32.load': 4, 'f64.load': 8,
@@ -37,6 +45,11 @@ export const OP = [
     'i64.load8_s': 1, 'i64.load8_u': 1, 'i64.load16_s': 2, 'i64.load16_u': 2, 'i64.load32_s': 4, 'i64.load32_u': 4, 'i32.store': 4,
     'i64.store': 8, 'f32.store': 4, 'f64.store': 8,
     'i32.store8': 1, 'i32.store16': 2, 'i64.store8': 1, 'i64.store16': 2, 'i64.store32': 4,
+
+    'v128.load': 16, 'v128.load8x8_s': 8, 'v128.load8x8_u': 8, 'v128.load16x4_s': 8, 'v128.load16x4_u': 8, 'v128.load32x2_s': 8, 'v128.load32x2_u': 8, 'v128.load8_splat': 1, 'v128.load16_splat': 2, 'v128.load32_splat': 4, 'v128.load64_splat': 8, 'v128.store': 16,
+    'v128.load': 16,
+
+    "v128.load8_lane": 1, "v128.load16_lane": 2, "v128.load32_lane": 4, "v128.load64_lane": 8, "v128.store8_lane": 1, "v128.store16_lane": 2, "v128.store32_lane": 4, "v128.store64_lane": 8, "v128.load32_zero": 4, "v128.load64_zero": 8
   },
   BLOCK = {
     loop: 1, block: 1, if: 1, end: -1, return: -1

package/src/encode.js

@@ -0,0 +1,123 @@
+// encoding ref: https://github.com/j-s-n/WebBS/blob/master/compiler/byteCode.js
+
+// uleb
+export const uleb = (n, buffer = []) => {
+  if (typeof n === 'string') n = i32.parse(n)
+
+  let byte = n & 0b01111111;
+  n = n >>> 7;
+
+  if (n === 0) {
+    buffer.push(byte);
+    return buffer;
+  } else {
+    buffer.push(byte | 0b10000000);
+    return uleb(n, buffer);
+  }
+}
+
+// leb
+export function i32(n, buffer = []) {
+  if (typeof n === 'string') n = i32.parse(n)
+
+  while (true) {
+    const byte = Number(n & 0x7F)
+    n >>= 7
+    if ((n === 0 && (byte & 0x40) === 0) || (n === -1 && (byte & 0x40) !== 0)) {
+      buffer.push(byte)
+      break
+    }
+    buffer.push((byte | 0x80))
+  }
+  return buffer
+}
+// alias
+export const i8 = i32, i16 = i32
+
+i32.parse = n => parseInt(n.replaceAll('_', ''))
+
+// bigleb
+export function i64(n, buffer = []) {
+  if (typeof n === 'string') n = i64.parse(n)
+
+  while (true) {
+    const byte = Number(n & 0x7Fn)
+    n >>= 7n
+    if ((n === 0n && (byte & 0x40) === 0) || (n === -1n && (byte & 0x40) !== 0)) {
+      buffer.push(byte)
+      break
+    }
+    buffer.push((byte | 0x80))
+  }
+  return buffer
+}
+i64.parse = n => {
+  n = n.replaceAll('_', '')
+  n = n[0] === '-' ? -BigInt(n.slice(1)) : BigInt(n)
+  byteView.setBigInt64(0, n)
+  return n = byteView.getBigInt64(0)
+}
+
+const byteView = new DataView(new BigInt64Array(1).buffer)
+
+const F32_SIGN = 0x80000000, F32_NAN = 0x7f800000
+export function f32(input, value, idx) {
+  if (~(idx = input.indexOf('nan:'))) {
+    value = parseInt(input.slice(idx + 4))
+    value |= F32_NAN
+    if (input[0] === '-') value |= F32_SIGN
+    byteView.setInt32(0, value)
+  }
+  else {
+    value = typeof input === 'string' ? f32.parse(input) : input
+    byteView.setFloat32(0, value);
+  }
+
+  return [
+    byteView.getUint8(3),
+    byteView.getUint8(2),
+    byteView.getUint8(1),
+    byteView.getUint8(0)
+  ];
+}
+
+const F64_SIGN = 0x8000000000000000n, F64_NAN = 0x7ff0000000000000n
+export function f64(input, value, idx) {
+  if (~(idx = input.indexOf('nan:'))) {
+    value = BigInt(input.slice(idx + 4))
+    value |= F64_NAN
+    if (input[0] === '-') value |= F64_SIGN
+    byteView.setBigInt64(0, value)
+  }
+  else {
+    value = typeof input === 'string' ? f64.parse(input) : input
+    byteView.setFloat64(0, value);
+  }
+
+  return [
+    byteView.getUint8(7),
+    byteView.getUint8(6),
+    byteView.getUint8(5),
+    byteView.getUint8(4),
+    byteView.getUint8(3),
+    byteView.getUint8(2),
+    byteView.getUint8(1),
+    byteView.getUint8(0)
+  ];
+}
+
+f32.parse = f64.parse = input => {
+  if (input.includes('nan')) return input[0] === '-' ? -NaN : NaN;
+  if (input.includes('inf')) return input[0] === '-' ? -Infinity : Infinity;
+
+  input = input.replaceAll('_', '')
+
+  // 0x1.5p3
+  if (input.includes('0x')) {
+    let [sig, exp] = input.split(/p/i), [dec, fract] = sig.split('.'), sign = dec[0] === '-' ? -1 : 1
+    sig = parseInt(dec) * sign + (fract ? parseInt(fract, 16) / (16 ** fract.length) : 0)
+    return sign * (exp ? sig * 2 ** parseInt(exp, 10) : sig);
+  }
+
+  return parseFloat(input)
+}

package/src/util.js

@@ -1,116 +1,3 @@
-// encoding ref: https://github.com/j-s-n/WebBS/blob/master/compiler/byteCode.js
-export const uleb = (n, buffer = []) => {
-  if (typeof n === 'string') n = parseInt(n.replaceAll('_', ''))
+export const TypedArray = { i64: BigInt64Array, i32: Int32Array, i16: Int16Array, i8: Int8Array, f64: Float64Array, f32: Float32Array }
 
-  let byte = n & 0b01111111;
-  n = n >>> 7;
-
-  if (n === 0) {
-    buffer.push(byte);
-    return buffer;
-  } else {
-    buffer.push(byte | 0b10000000);
-    return uleb(n, buffer);
-  }
-}
-
-export function leb(n, buffer = []) {
-  if (typeof n === 'string') n = parseInt(n.replaceAll('_', ''))
-
-  while (true) {
-    const byte = Number(n & 0x7F)
-    n >>= 7
-    if ((n === 0 && (byte & 0x40) === 0) || (n === -1 && (byte & 0x40) !== 0)) {
-      buffer.push(byte)
-      break
-    }
-    buffer.push((byte | 0x80))
-  }
-  return buffer
-}
-
-export function bigleb(n, buffer = []) {
-  if (typeof n === 'string') {
-    n = n.replaceAll('_', '')
-    n = n[0] === '-' ? -BigInt(n.slice(1)) : BigInt(n)
-    byteView.setBigInt64(0, n)
-    n = byteView.getBigInt64(0)
-  }
-
-  while (true) {
-    const byte = Number(n & 0x7Fn)
-    n >>= 7n
-    if ((n === 0n && (byte & 0x40) === 0) || (n === -1n && (byte & 0x40) !== 0)) {
-      buffer.push(byte)
-      break
-    }
-    buffer.push((byte | 0x80))
-  }
-  return buffer
-}
-
-// generalized float cases parser
-const flt = input => {
-  if (input.includes('nan')) return input[0] === '-' ? -NaN : NaN;
-  if (input.includes('inf')) return input[0] === '-' ? -Infinity : Infinity;
-
-  input = input.replaceAll('_', '')
-
-  // 0x1.5p3
-  if (input.includes('0x')) {
-    let [sig, exp] = input.split(/p/i), [dec, fract] = sig.split('.'), sign = dec[0] === '-' ? -1 : 1
-    sig = parseInt(dec) * sign + (fract ? parseInt(fract, 16) / (16 ** fract.length) : 0)
-    return sign * (exp ? sig * 2 ** parseInt(exp, 10) : sig);
-  }
-
-  return parseFloat(input)
-}
-
-
-const byteView = new DataView(new BigInt64Array(1).buffer)
-
-const F32_SIGN = 0x80000000, F32_NAN = 0x7f800000
-export function f32(input, value, idx) {
-  if (~(idx = input.indexOf('nan:'))) {
-    value = parseInt(input.slice(idx + 4))
-    value |= F32_NAN
-    if (input[0] === '-') value |= F32_SIGN
-    byteView.setInt32(0, value)
-  }
-  else {
-    value = typeof input === 'string' ? flt(input) : input
-    byteView.setFloat32(0, value);
-  }
-
-  return [
-    byteView.getUint8(3),
-    byteView.getUint8(2),
-    byteView.getUint8(1),
-    byteView.getUint8(0)
-  ];
-}
-
-const F64_SIGN = 0x8000000000000000n, F64_NAN = 0x7ff0000000000000n
-export function f64(input, value, idx) {
-  if (~(idx = input.indexOf('nan:'))) {
-    value = BigInt(input.slice(idx + 4))
-    value |= F64_NAN
-    if (input[0] === '-') value |= F64_SIGN
-    byteView.setBigInt64(0, value)
-  }
-  else {
-    value = typeof input === 'string' ? flt(input) : input
-    byteView.setFloat64(0, value);
-  }
-
-  return [
-    byteView.getUint8(7),
-    byteView.getUint8(6),
-    byteView.getUint8(5),
-    byteView.getUint8(4),
-    byteView.getUint8(3),
-    byteView.getUint8(2),
-    byteView.getUint8(1),
-    byteView.getUint8(0)
-  ];
-}
+export const err = text => { throw Error(text) }