watr 2.4.1 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watr",
-  "version": "2.4.1",
+  "version": "3.0.0",
   "description": "Ligth & fast WAT compiler",
   "main": "watr.js",
   "exports": {
@@ -11,7 +11,8 @@
   },
   "type": "module",
   "scripts": {
-    "test": "node test"
+    "test": "node test",
+    "postinstall": "git submodule update --init --recursive"
   },
   "repository": {
     "type": "git",
@@ -30,7 +31,9 @@
     "wabt",
     "pretty-print",
     "webassembly",
-    "wasm-text"
+    "wasm-text",
+    "wast",
+    "wat-compiler"
   ],
   "author": "Dmitry Iv",
   "license": "MIT",

package/readme.md

@@ -1,6 +1,6 @@
 # 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. A light & fast alternative to [wat2wasm](https://github.com/AssemblyScript/wabt.js).<br/>
+Light & fast WASM compiler. An alternative to [wabt/wat2wasm](https://github.com/AssemblyScript/wabt.js).<br/>
 Useful for hi-level languages or dynamic (in-browser) compilation.<br>
 
 ## Usage
@@ -10,7 +10,7 @@ Useful for hi-level languages or dynamic (in-browser) compilation.<br>
 Compile wasm text or syntax tree into wasm binary.
 
 ```js
-import compile from 'watr' // or `import { compile } from 'watr'`
+import { compile } from 'watr'
 
 const buffer = compile(`(func (export "double")
   (param f64) (result f64)
@@ -23,6 +23,20 @@ const {double} = instance.exports
 double(108) // 216
 ```
 
+### Parse
+
+Parse input wasm text into syntax tree.
+
+```js
+import { parse } from 'watr'
+
+parse(`(func (export "double") (param f64) (result f64) (f64.mul (local.get 0) (f64.const 2)))`)
+// [
+//   'func', ['export', '"double"'], ['param', 'f64'], ['result', 'f64'],
+//   ['f64.mul', ['local.get', 0], ['f64.const', 2]]
+// ]
+```
+
 ### Print
 
 Format input wasm text or syntax tree into minified or pretty form.
@@ -54,54 +68,55 @@ print(src, {
 // (func (export "double")(param f64)(result f64)(f64.mul (local.get 0)(f64.const 2)))
 ```
 
-### Parse
-
-Parse input wasm text into syntax tree.
-
-```js
-import { parse } from 'watr'
-
-parse(`(func (export "double") (param f64) (result f64) (f64.mul (local.get 0) (f64.const 2)))`)
-// [
-//   'func', ['export', '"double"'], ['param', 'f64'], ['result', 'f64'],
-//   ['f64.mul', ['local.get', 0], ['f64.const', 2]]
-// ]
-```
-
 <!-- See [REPL](https://audio-lab.github.io/watr/repl.html).-->
 
 ## Status
 
 * [x] core
+* [x] [mutable_globals](https://github.com/WebAssembly/mutable-global)
+* [x] [extended const](https://github.com/WebAssembly/extended-const/blob/main/proposals/extended-const/Overview.md)
+* [ ] [sat_float_to_int](https://github.com/WebAssembly/nontrapping-float-to-int-conversions)
+* [ ] [sign_extension](https://github.com/WebAssembly/sign-extension-ops)
 * [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)
+* [ ] [memory64](https://github.com/WebAssembly/memory64)
+* [x] [multiple memories](https://github.com/WebAssembly/multi-memory/blob/master/proposals/multi-memory/Overview.md)
 * [x] [simd](https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md)
-* [x] [extended const](https://github.com/WebAssembly/extended-const/blob/main/proposals/extended-const/Overview.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)
+* [ ] [relaxed_simd](https://github.com/WebAssembly/relaxed-simd)
+* [x] [ref types](https://github.com/WebAssembly/reference-types/blob/master/proposals/reference-types/Overview.md)
+* [x] [func refs](https://github.com/WebAssembly/function-references/blob/main/proposals/function-references/Overview.md)
 * [ ] [gc](https://github.com/WebAssembly/gc)
+* [ ] [exceptions](https://github.com/WebAssembly/exception-handling)
+* [ ] [threads](https://github.com/WebAssembly/threads)
+* [ ] [tail_call](https://github.com/WebAssembly/tail-call)
+* [ ] [annotations](https://github.com/WebAssembly/annotations)
+* [ ] [code_metadata](https://github.com/WebAssembly/tool-conventions/blob/main/CodeMetadata.md)
 
 ## Alternatives
 
 &nbsp; | Size (gzipped) | Performance (op/s)
 ---|---|---
 watr | 5 kb | 6000
-[wat-compiler](https://github.com/stagas/wat-compiler) | 6 kb | 348
 [wabt](https://github.com/AssemblyScript/wabt.js) | 300 kb | 574
+[wat-compiler](https://github.com/stagas/wat-compiler) | 6 kb | 348
 <!-- [wassemble](https://github.com/wingo/wassemble) | ? kb | ? -->
 
+<!-- Watr has better syntax support than wabt & produces more compact output due to types squash. -->
+
 <!--
 ## Projects using watr
 
-* [auro](https://github.com/audio-lab/auro) – audio processing language
+* [piezo](https://github.com/audio-lab/piezo) – audio processing language
 -->
 
+<!--
 ## Useful links
 
 * [watlings](https://github.com/EmNudge/watlings) – learn Wasm text by examples.
 * [MDN: control flow](https://developer.mozilla.org/en-US/docs/WebAssembly/Reference/Control_flow)
 * [WASM reference manual](https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#loop)
 * [WASM binary encoding](https://github.com/WebAssembly/design/blob/main/BinaryEncoding.md)
+-->
 
 <!--
 ## Refs

package/src/compile.js

@@ -1,140 +1,203 @@
 import * as encode from './encode.js'
 import { uleb } from './encode.js'
-import { OP, SECTION, ALIGN, TYPE, KIND } from './const.js'
+import { SECTION, ALIGN, TYPE, KIND, INSTR } from './const.js'
 import parse from './parse.js'
-import { err } from './util.js'
 
+// build instructions index
+INSTR.forEach((instr, i) => {
+  let [op, ...imm] = instr.split(':'), a, b
+
+  // TODO
+  // wrap codes
+  // const code = i >= 0x10f ? [0xfd, i - 0x10f] : i >= 0xfc ? [0xfc, i - 0xfc] : i
+  INSTR[op] = i
+
+  // // handle immediates
+  // INSTR[op] = !imm.length ? () => code :
+  //   imm.length === 1 ? (a = immedname(imm[0]), nodes => [...code, ...a(nodes)]) :
+  //     (imm = imm.map(immedname), nodes => [...code, ...imm.flatMap(imm => imm(nodes))])
+})
 
 /**
- * Converts a WebAssembly Text Format (WAT) tree to a WebAssembly binary format (Wasm).
+ * Converts a WebAssembly Text Format (WAT) tree to a WebAssembly binary format (WASM).
  *
- * @param {string|Array} nodes - The WAT tree or string to be compiled to Wasm binary.
- * @returns {Uint8Array} The compiled Wasm binary data.
+ * @param {string|Array} nodes - The WAT tree or string to be compiled to WASM binary.
+ * @returns {Uint8Array} The compiled WASM binary data.
  */
 export default (nodes) => {
-  if (typeof nodes === 'string') nodes = parse(nodes);
+  // normalize to (module ...) form
+  if (typeof nodes === 'string') nodes = parse(nodes); else nodes = [...nodes]
+
+  // module abbr https://webassembly.github.io/spec/core/text/modules.html#id10
+  if (nodes[0] === 'module') nodes.shift(), id(nodes)
+  else if (typeof nodes[0] === 'string') nodes = [nodes]
+
+  // Scopes are stored directly on section array by key, eg. section.func.$name = idx
+  // FIXME: make direct binary instead (faster)
+  const sections = []
+  for (let kind in SECTION) sections.push(sections[kind] = [])
 
-  // IR. Alias is stored directly to section array by key, eg. section.func.$name = idx
-  let sections = {
-    type: [], import: [], func: [], table: [], memory: [], global: [], export: [], start: [], elem: [], code: [], data: []
-  }, binary = [
+  const binary = [
     0x00, 0x61, 0x73, 0x6d, // magic
     0x01, 0x00, 0x00, 0x00, // version
   ]
 
-  // 1. transform tree
-  // (func) → [(func)]
-  if (typeof nodes[0] === 'string' && nodes[0] !== 'module') nodes = [nodes]
-
-  // (global $a (import "a" "b") (mut i32)) → (import "a" "b" (global $a (mut i32)))
-  // (memory (import "a" "b") min max shared) → (import "a" "b" (memory min max shared))
-  nodes = nodes.map(node => {
-    if (node[2]?.[0] === 'import') {
-      let [kind, name, imp, ...args] = node
-      return [...imp, [kind, name, ...args]]
+  // sort nodes by sections
+  // TODO: make this more elegant
+  let nodeGroups = []
+  for (let kind in SECTION) nodeGroups.push(nodeGroups[kind] = [])
+
+  for (let [kind, ...node] of nodes) {
+    // index, alias
+    let name = id(node), idx = nodeGroups[kind].length;
+    if (name) sections[kind][name] = idx; // save alias
+
+    // export abbr
+    // (table|memory|global|func id? (export n)* ...) -> (table|memory|global|func id ...) (export n (table|memory|global|func id))
+    while (node[0]?.[0] === 'export') nodeGroups.export.push([node.shift()[1], [kind, idx]])
+
+    // import abbr
+    // (table|memory|global|func id? (import m n) type) -> (import m n (table|memory|global|func id? type))
+    if (node[0]?.[0] === 'import') node = [...node.shift(), [kind, ...(name ? [name] : []), ...node]], kind = node.shift()
+
+    // table abbr
+    // (table id? reftype (elem ...{n})) -> (table id? n n reftype) (elem (table id) (i32.const 0) reftype ...)
+    if (node[1]?.[0] === 'elem') {
+      let [reftype, [, ...els]] = node
+      node = [els.length, els.length, reftype]
+      nodeGroups.elem.push([['table', name || nodeGroups.table.length], ['i32.const', '0'],  typeof els[0] === 'string' ? 'func' : reftype, ...els])
     }
-    else if (node[1]?.[0] === 'import') {
-      let [kind, imp, ...args] = node
-      return [...imp, [kind, ...args]]
+
+    // data abbr
+    // (memory id? (data str)) -> (memory id? n n) (data (memory id) (i32.const 0) str)
+    if (node[0]?.[0] === 'data') {
+      let [,...data] = node.shift(), m = ''+Math.ceil(data.map(s => s.slice(1,-1)).join('').length / 65536) // FIXME: figure out actual data size
+      nodeGroups.data.push([['memory', idx], ['i32.const',0], ...data])
+      node = [m, m]
     }
-    return node
-  })
 
-  // 2. build IR. import must be initialized first, global before func, elem after func
-  let order = ['type', 'import', 'table', 'memory', 'global', 'func', 'export', 'start', 'elem', 'data'], postcall = []
 
-  for (let name of order) {
-    let remaining = []
-    for (let node of nodes) {
-      node[0] === name ? postcall.push(build[name](node, sections)) : remaining.push(node)
+    // import increments corresponding section index
+    // FIXME: can be turned into shallow node
+    if (kind === 'import') {
+      let [mod, field, [kind, ...dfn]] = node
+      let name = id(dfn)
+      if (name) sections[kind][name] = nodeGroups[kind].length
+      nodeGroups[kind].length++
+      node[2] = [kind, ...dfn]
     }
-    nodes = remaining
+    else if (kind === 'start') {name && node.unshift(name);}
+
+    nodeGroups[kind].push(node)
   }
 
-  // code must be compiled after all definitions
-  for (let cb of postcall) cb?.()
-
-  // 3. build binary
-  for (let name in sections) {
-    let items = sections[name]
-    if (items.importc) items = items.slice(items.importc) // discard imported functions/globals
-    if (!items.length) continue
-    let sectionCode = SECTION[name], bytes = []
-    if (sectionCode !== 8) bytes.push(items.length) // skip start section count
-    for (let item of items) bytes.push(...item)
-    binary.push(sectionCode, ...uleb(bytes.length), ...bytes)
+  // build sections binaries
+  for (let kind in SECTION) nodeGroups[kind].map((node,i) => !node ? [] : build[kind](i, node, sections))
+
+  // build final binary
+  for (let secCode = 0; secCode < sections.length; secCode++) {
+    let items = sections[secCode], bytes = [], count = 0
+    for (let item of items) {
+      if (!item) { continue } // ignore empty items (like import placeholders)
+      count++ // count number of items in section
+      bytes.push(...item)
+    }
+    // ignore empty sections
+    if (!bytes.length) continue
+    // skip start section count - write length
+    if (secCode !== 8) bytes.unshift(...uleb(count))
+    binary.push(secCode, ...vec(bytes))
   }
 
   return new Uint8Array(binary)
 }
 
+// consume $id
+const id = nodes => nodes[0]?.[0] === '$' && nodes.shift()
+
+// build section binary (non consuming)
 const build = {
-  // (type $name? (func (param $x i32) (param i64 i32) (result i32 i64)))
-  // signature part is identical to function
-  // FIXME: handle non-function types
-  type([, typeName, [kind, ...sig]], ctx) {
-    if (kind !== 'func') err(`Unknown type kind '${kind}'`)
-    const [idx] = consumeType(sig, ctx)
-    if (typeName) ctx.type[typeName] = idx
+  // (type $id? (func params result))
+  // we cannot squash types since indices can refer to them
+  type(idx, [...node], ctx) {
+    let [, ...sig] = node?.[0] || [], [param, result] = paramres(sig)
+
+    ctx.type[idx] = Object.assign(
+      [TYPE.func, ...vec(param.map(t => TYPE[t])), ...vec(result.map(t => TYPE[t]))],
+      { param, result } // save params for the type name
+    )
+    ctx.type[param + '>' + result] ??= idx // alias for quick search (don't increment if exists)
   },
 
-  // (func $name? ...params result ...body)
-  func([, ...body], ctx) {
-    let locals = [], // list of local variables
-      blocks = [] // control instructions / blocks stack
+  // (import "math" "add" (func|table|global|memory typedef?))
+  import(_, [mod, field, [kind, ...dfn]], ctx) {
+    let details
 
-    // fn name
-    if (body[0]?.[0] === '$') ctx.func[body.shift()] = ctx.func.length
+    if (kind === 'func') {
+      // we track imported funcs in func section to share namespace, and skip them on final build
+      let [typeIdx] = typeuse(dfn, ctx)
+      details = uleb(typeIdx)
+    }
+    else if (kind === 'memory') {
+      details = limits(dfn)
+    }
+    else if (kind === 'global') {
+      let [type] = dfn, mut = type[0] === 'mut' ? 1 : 0
+      details = [TYPE[mut ? type[1] : type], mut]
+    }
+    else if (kind === 'table') {
+      details = [TYPE[dfn.pop()], ...limits(dfn)]
+    }
+
+    ctx.import.push([...str(mod), ...str(field), KIND[kind], ...details])
+  },
 
-    // export binding
-    if (body[0]?.[0] === 'export') build.export([...body.shift(), ['func', ctx.func.length]], ctx)
+  // (func $name? ...params result ...body)
+  func(idx, [...node], ctx) {
+    const [typeidx, param, result] = typeuse(node, ctx)
 
-    // register/consume type info
-    let [typeIdx, params, result] = consumeType(body, ctx)
+    ctx.func[idx] = uleb(typeidx)
 
-    // register new function
-    ctx.func.push([typeIdx])
+    // build code section
+    let blocks = [] // control instructions / blocks stack
+    let locals = [] // list of local variables
 
     // collect locals
-    while (body[0]?.[0] === 'local') {
-      let [, ...types] = body.shift(), name
-      if (types[0][0] === '$')
-        params[name = types.shift()] ? err('Ambiguous name ' + name) :
-          locals[name] = params.length + locals.length
+    while (node[0]?.[0] === 'local') {
+      let [, ...types] = node.shift(), name
+      if (types[0]?.[0] === '$')
+        param[name = types.shift()] ? err('Ambiguous name ' + name) : // FIXME: not supposed to happen
+          locals[name] = param.length + locals.length
       locals.push(...types.map(t => TYPE[t]))
     }
 
-    // squash local types
-    let locTypes = locals.reduce((a, type) => (type == a[a.length - 1] ? a[a.length - 2]++ : a.push(1, type), a), [])
-
     // convert sequence of instructions from input nodes to out bytes
+    // FIXME: make external func
     const consume = (nodes, out = []) => {
       if (!nodes?.length) return out
 
       let op = nodes.shift(), opCode, args = nodes, immed, id, group
 
-      // groups are flattened, eg. (cmd z w) -> z w cmd
+      // flatten groups, eg. (cmd z w) -> z w cmd
       if (group = Array.isArray(op)) {
         args = [...op] // op is immutable
-        opCode = OP.indexOf(op = args.shift())
+        opCode = INSTR[op = args.shift()]
       }
-      else opCode = OP.indexOf(op)
-
-      // NOTE: numeric comparison is faster than generic hash lookup
+      else opCode = INSTR[op]
 
       // v128s: (v128.load x) etc
       // https://github.com/WebAssembly/simd/blob/master/proposals/simd/BinarySIMD.md
-      if (opCode >= 268) {
-        opCode -= 268
+      if (opCode >= 0x10f) {
+        opCode -= 0x10f
         immed = [0xfd, ...uleb(opCode)]
         // (v128.load)
         if (opCode <= 0x0b) {
-          const o = consumeParams(args)
+          const o = memarg(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)
+          const o = memarg(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()))
@@ -147,7 +210,7 @@ const build = {
         // (v128.const i32x4)
         else if (opCode === 0x0c) {
           args.unshift(op)
-          immed = consumeConst(args, ctx)
+          immed = expr(args, ctx)
         }
         // (i8x16.extract_lane_s 0 ...)
         else if (opCode >= 0x15 && opCode <= 0x22) {
@@ -158,8 +221,8 @@ const build = {
 
       // bulk memory: (memory.init) (memory.copy) etc
       // https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md#instruction-encoding
-      else if (opCode >= 252) {
-        immed = [0xfc, ...uleb(opCode -= 252)]
+      else if (opCode >= 0xfc) {
+        immed = [0xfc, ...uleb(opCode -= 0xfc)]
         // memory.init idx, memory.drop idx, table.init idx, table.drop idx
         if (!(opCode & 0b10)) immed.push(...uleb(args.shift()))
         else immed.push(0)
@@ -168,13 +231,22 @@ const build = {
         opCode = null // ignore opcode
       }
 
+      // ref.func $id
+      else if (opCode == 0xd2) {
+        immed = uleb(args[0][0] === '$' ? ctx.func[args.shift()] : +args.shift())
+      }
+      // ref.null
+      else if (opCode == 0xd0) {
+        immed = [TYPE[args.shift() + 'ref']] // func->funcref, extern->externref
+      }
+
       // binary/unary (i32.add a b) - no immed
       else if (opCode >= 0x45) { }
 
       // (i32.store align=n offset=m at value) etc
-      else if (opCode >= 40 && opCode <= 62) {
+      else if (opCode >= 0x28 && opCode <= 0x3e) {
         // FIXME: figure out point in Math.log2 aligns
-        let o = consumeParams(args)
+        let o = memarg(args)
         immed = [Math.log2(o.align ?? ALIGN[op]), ...uleb(o.offset ?? 0)]
       }
 
@@ -184,32 +256,27 @@ const build = {
       }
 
       // (local.get $id), (local.tee $id x)
-      else if (opCode >= 32 && opCode <= 34) {
-        immed = uleb(args[0]?.[0] === '$' ? params[id = args.shift()] || locals[id] : args.shift())
+      else if (opCode >= 0x20 && opCode <= 0x22) {
+        immed = uleb(args[0]?.[0] === '$' ? param[id = args.shift()] ?? locals[id] ?? err('Unknown local ' + id) : +args.shift())
       }
 
-      // (global.get id), (global.set id)
-      else if (opCode == 0x23 || opCode == 36) {
-        immed = uleb(args[0]?.[0] === '$' ? ctx.global[args.shift()] : args.shift())
+      // (global.get $id), (global.set $id)
+      else if (opCode == 0x23 || opCode == 0x24) {
+        immed = uleb(args[0]?.[0] === '$' ? ctx.global[args.shift()] : +args.shift())
       }
 
       // (call id ...nodes)
-      else if (opCode == 16) {
+      else if (opCode == 0x10) {
         let fnName = args.shift()
-        immed = uleb(id = fnName[0] === '$' ? ctx.func[fnName] ?? err('Unknown function `' + fnName + '`') : fnName);
+        immed = uleb(id = fnName[0] === '$' ? ctx.func[fnName] : +fnName);
         // FIXME: how to get signature of imported function
       }
 
-      // (call_indirect (type $typeName) (idx) ...nodes)
-      else if (opCode == 17) {
-        let typeId = args.shift()[1];
-        typeId = typeId[0] === '$' ? ctx.type[typeId] : typeId
-        immed = uleb(typeId), immed.push(0) // extra immediate indicates table idx (reserved)
-      }
-
-      // FIXME multiple memory (memory.grow $idx?)
-      else if (opCode == 63 || opCode == 64) {
-        immed = [0]
+      // (call_indirect tableIdx? (type $typeName) (idx) ...nodes)
+      else if (opCode == 0x11) {
+        let tableidx = args[0]?.[0] === '$' ? ctx.table[args.shift()] : 0
+        let [typeidx] = typeuse(args, ctx)
+        immed = [...uleb(typeidx), ...uleb(tableidx)]
       }
 
       // (block ...), (loop ...), (if ...)
@@ -217,9 +284,9 @@ const build = {
         blocks.push(opCode)
 
         // (block $x) (loop $y)
-        if (opCode < 4 && args[0]?.[0] === '$') (blocks[args.shift()] = blocks.length)
+        if (args[0]?.[0] === '$') (blocks[args.shift()] = blocks.length)
 
-        // get type
+        // get type - can be either typeidx or valtype (numtype | reftype)
         // (result i32) - doesn't require registering type
         if (args[0]?.[0] === 'result' && args[0].length < 3) {
           let [, type] = args.shift()
@@ -227,8 +294,15 @@ const build = {
         }
         // (result i32 i32)
         else if (args[0]?.[0] === 'result' || args[0]?.[0] === 'param') {
-          let [typeId] = consumeType(args, ctx)
-          immed = [typeId]
+          let [typeidx] = typeuse(args, ctx)
+          immed = uleb(typeidx)
+        }
+        // FIXME: that def can be done nicer
+        else if (args[0]?.[0] === 'type') {
+          let [typeidx, params, result] = typeuse(args, ctx)
+          if (!params.length && !result.length) immed = [TYPE.void]
+          else if (!param.length && result.length === 1) immed = [TYPE[result[0]]]
+          else immed = uleb(typeidx)
         }
         else {
           immed = [TYPE.void]
@@ -239,7 +313,6 @@ const build = {
           nodes.unshift('end')
 
           if (opCode < 4) while (args.length) nodes.unshift(args.pop())
-
           // (if cond a) -> cond if a end
           else if (args.length < 3) nodes.unshift(args.pop())
           // (if cond (then a) (else b)) -> `cond if a else b end`
@@ -277,129 +350,187 @@ const build = {
       // (br_table 1 2 3 4  0  selector result?)
       else if (opCode == 0x0e) {
         immed = []
-        while (!Array.isArray(args[0])) id = args.shift(), immed.push(...uleb(id[0][0] === '$' ? blocks.length - blocks[id] : id))
+        while (args[0] && !Array.isArray(args[0])) {
+          id = args.shift()
+          immed.push(...uleb(id[0][0] === '$' ? blocks.length - blocks[id] : id))
+        }
         immed.unshift(...uleb(immed.length - 1))
       }
-      else if (opCode < 0) err(`Unknown instruction \`${op}\``)
+
+      // FIXME multiple memory (memory.grow $idx?)
+      else if (opCode == 0x3f || opCode == 0x40) {
+        immed = [0]
+      }
+
+      // (table.get $id)
+      else if (opCode == 0x25 || opCode == 0x26) {
+        immed = uleb(args[0]?.[0] === '$' ? ctx.table[args.shift()] : +args.shift())
+      }
+
+      // table.grow id, table.size id, table.fill id
+      else if (opCode >= 0x0f && opCode <= 0x11) {
+        immed = []
+      }
+
+      else if (opCode == null) err(`Unknown instruction \`${op}\``)
 
       // if group (cmd im1 im2 arg1 arg2) - insert any remaining args first: arg1 arg2
       // because inline case has them in stack already
-      if (group) {
-        while (args.length) consume(args, out)
-      }
+      if (group) while (args.length) consume(args, out)
 
-      if (opCode) out.push(opCode)
+      if (opCode != null) out.push(opCode)
       if (immed) out.push(...immed)
     }
 
-    // evaluates after all definitions (need globals, elements, data etc.)
-    // FIXME: get rid of this postcall
-    return () => {
-      const bytes = []
-      while (body.length) consume(body, bytes)
-      ctx.code.push([...uleb(bytes.length + 2 + locTypes.length), ...uleb(locTypes.length >> 1), ...locTypes, ...bytes, 0x0b])
-    }
-  },
+    const bytes = []
+    // FIXME: avoid passing bytes from outside, push result instead
+    while (node.length) consume(node, bytes)
+    bytes.push(0x0b)
+
+    // squash locals into (n:u32 t:valtype)*, n is number and t is type
+    let loctypes = locals.reduce((a, type) => (type == a[a.length - 1]?.[1] ? a[a.length - 1][0]++ : a.push([1, type]), a), [])
 
-  // (memory min max shared)
-  // (memory $name min max shared)
-  // (memory (export "mem") 5)
-  memory([, ...parts], ctx) {
-    if (parts[0][0] === '$') ctx.memory[parts.shift()] = ctx.memory.length
-    if (parts[0][0] === 'export') build.export([...parts.shift(), ['memory', ctx.memory.length]], ctx)
-    ctx.memory.push(range(parts))
+    // https://webassembly.github.io/spec/core/binary/modules.html#code-section
+    ctx.code[idx] = vec([...uleb(loctypes.length), ...loctypes.flatMap(([n, t]) => [...uleb(n), t]), ...bytes])
   },
 
-  // (global i32 (i32.const 42))
-  // (global $id i32 (i32.const 42))
-  // (global $id (mut i32) (i32.const 42))
-  global([, ...args], ctx) {
-    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, ...consumeConst(init, ctx), 0x0b])
+  // (table id? 1 2? funcref)
+  table(idx, [...node], ctx) {
+    ctx.table[idx] = [TYPE[node.pop()], ...limits(node)]
   },
 
-  // (table 1 2? funcref)
-  // (table $name 1 2? funcref)
-  table([, ...args], ctx) {
-    let name = args[0][0] === '$' && args.shift()
-    if (name) ctx.table[name] = ctx.table.length
-    let lims = range(args)
-    ctx.table.push([TYPE[args.pop()], ...lims])
+  // (memory id? export* min max shared)
+  memory(idx, [...node], ctx) {
+    ctx.memory[idx] = limits(node)
   },
 
-  // (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, ...consumeConst(offset, ctx), 0x0b, ...uleb(elems.length), ...elems.flatMap(el => uleb(el[0] === '$' ? ctx.func[el] : el))])
+  // (global $id? (mut i32) (i32.const 42))
+  global(idx, [...node], ctx) {
+    let [type] = node, mut = type[0] === 'mut' ? 1 : 0
+
+    let [, [...init]] = node
+    ctx.global[idx] = [TYPE[mut ? type[1] : type], mut, ...expr(init, ctx), 0x0b]
   },
 
-  //  (export "name" (kind $name|idx))
-  export([, name, [kind, idx]], ctx) {
-    if (idx[0] === '$') idx = ctx[kind][idx]
-    ctx.export.push([...str(name), KIND[kind], ...uleb(idx)])
+  //  (export "name" (func|table|mem $name|idx))
+  export(_, [nm, [kind, id]], ctx) {
+    // put placeholder to future-init
+    let idx = id[0] === '$' ? ctx[kind][id] : +id
+    ctx.export.push([...str(nm), KIND[kind], ...uleb(idx)])
   },
 
-  // (import "math" "add" (func $add (param i32 i32 externref) (result i32)))
-  // (import "js" "mem" (memory 1))
-  // (import "js" "mem" (memory $name 1))
-  // (import "js" "v" (global $name (mut f64)))
-  import([, mod, field, ref], ctx) {
-    let details, [kind, ...parts] = ref,
-      name = parts[0]?.[0] === '$' && parts.shift();
+  // (start $main)
+  start(_,[id], ctx) {
+    id = id[0] === '$' ? ctx.func[id] : +id
+    ctx.start[0] = uleb(id)
+  },
 
-    if (kind === 'func') {
-      // we track imported funcs in func section to share namespace, and skip them on final build
-      if (name) ctx.func[name] = ctx.func.length
-      let [typeIdx] = consumeType(parts, ctx)
-      ctx.func.push(details = uleb(typeIdx))
-      ctx.func.importc = (ctx.func.importc || 0) + 1
-    }
-    else if (kind === 'memory') {
-      if (name) ctx.memory[name] = ctx.memory.length
-      details = range(parts)
+  // ref: https://webassembly.github.io/spec/core/binary/modules.html#element-section
+  // passive: (elem elem*)
+  // declarative: (elem declare elem*)
+  // active: (elem (table idx)? (offset expr)|(expr) elem*)
+  // elems: funcref|externref (item expr)|expr (item expr)|expr
+  // idxs: func? $id0 $id1
+  elem(idx,[...parts], ctx) {
+    let tabidx, offset, mode = 0b000, reftype
+
+    // declare?
+    if (parts[0] === 'declare') parts.shift(), mode |= 0b010
+
+    // table?
+    if (parts[0][0] === 'table') {
+      [, tabidx] = parts.shift()
+      tabidx = tabidx[0] === '$' ? ctx.table[tabidx] : +tabidx
+      // ignore table=0
+      if (tabidx) mode |= 0b010
     }
-    else if (kind === 'global') {
-      // imported globals share namespace with internal globals - we skip them in final build
-      if (name) ctx.global[name] = ctx.global.length
-      let [type] = parts, mut = type[0] === 'mut' ? 1 : 0
-      details = [TYPE[mut ? type[1] : type], mut]
-      ctx.global.push(details)
-      ctx.global.importc = (ctx.global.importc || 0) + 1
-    }
-    else throw Error('Unimplemented ' + kind)
 
-    ctx.import.push([...str(mod), ...str(field), KIND[kind], ...details])
+    // (offset expr)|expr
+    if (parts[0]?.[0] === 'offset' || (Array.isArray(parts[0]) && parts[0][0] !== 'item' && !parts[0][0].startsWith('ref'))) {
+      [...offset] = parts.shift()
+      if (offset[0] === 'offset') [, [...offset]] = offset
+    }
+    else mode |= 0b001 // passive
+
+    // funcref|externref|func
+    if (parts[0]?.[0]!=='$') reftype = parts.shift()
+    // externref makes explicit table index
+    if (reftype === 'externref') offset ||= ['i32.const', 0], mode = 0b110
+
+    // reset to simplest mode if no actual elements
+    if (!parts.length) mode &= 0b011
+
+    // simplify els
+    parts = parts.map(el => {
+      if (el[0] === 'item') [, el] = el
+      if (el[0] === 'ref.func') [, el] = el
+      // (ref.null func) and other expressions
+      if (typeof el !== 'string') mode |= 0b100
+      return el
+    })
+
+    ctx.elem[idx] = ([
+      mode,
+      ...(
+        // 0b000 e:expr y*:vec(funcidx)                     | type=funcref, init ((ref.func y)end)*, active (table=0,offset=e)
+        mode === 0b000 ? [...expr(offset, ctx), 0x0b] :
+          // 0b001 et:elkind y*:vec(funcidx)                  | type=0x00, init ((ref.func y)end)*, passive
+          mode === 0b001 ? [0x00] :
+            // 0b010 x:tabidx e:expr et:elkind y*:vec(funcidx)  | type=0x00, init ((ref.func y)end)*, active (table=x,offset=e)
+            mode === 0b010 ? [...uleb(tabidx || 0), ...expr(offset), 0x0b, 0x00] :
+              // 0b011 et:elkind y*:vec(funcidx)                  | type=0x00, init ((ref.func y)end)*, passive declare
+              mode === 0b011 ? [0x00] :
+                // 0b100 e:expr el*:vec(expr)                       | type=funcref, init el*, active (table=0, offset=e)
+                mode === 0b100 ? [...expr(offset, ctx), 0x0b] :
+                  // 0b101 et:reftype el*:vec(expr)                   | type=et, init el*, passive
+                  mode === 0b101 ? [TYPE[reftype]] :
+                    // 0b110 x:tabidx e:expr et:reftype el*:vec(expr)   | type=et, init el*, active (table=x, offset=e)
+                    mode === 0b110 ? [...uleb(tabidx || 0), ...expr(offset), 0x0b, TYPE[reftype]] :
+                      // 0b111 et:reftype el*:vec(expr)                   | type=et, init el*, passive declare
+                      [TYPE[reftype]]
+      ),
+      ...uleb(parts.length),
+      ...parts.flatMap(mode & 0b100 ?
+        // ((ref.func y)end)*
+        el => [...expr(typeof el === 'string' ? ['ref.func', el] : [...el], ctx), 0x0b] :
+        // el*
+        el => uleb(el[0] === '$' ? ctx.func[el] : +el)
+      )
+    ])
   },
 
   // (data (i32.const 0) "\aa" "\bb"?)
-  // (data (offset (i32.const 0)) (memory ref) "\aa" "\bb"?)
+  // (data (memory ref) (offset (i32.const 0)) "\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, ...consumeConst([...offset], ctx), 0x0b, ...str(inits.map(i => i[0] === '"' ? i.slice(1, -1) : i).join(''))])
-  },
+  data(idx, [...inits], ctx) {
+    let offset, mem = [0]
+
+    // (memory ref)?
+    if (inits[0]?.[0] === 'memory') {
+      [, mem] = inits.shift()
+      mem = mem[0] === '$' ? ctx.memory[mem] : +mem
+      mem = !mem ? [0] : [2, ...uleb(mem)]
+    }
 
-  // (start $main)
-  start([, name], ctx) {
-    if (!ctx.start.length) ctx.start.push([name[0] === '$' ? ctx.func[name] : name])
+    // (offset (i32.const 0)) or (i32.const 0)
+    if (typeof inits[0] !== 'string') {
+      offset = inits.shift()
+      if (offset[0] === 'offset') [, offset] = offset
+    }
+    else offset = ['i32.const', 0]
+    ctx.data[idx] = [...mem, ...expr([...offset], ctx), 0x0b, ...str(inits.map(i => i.slice(1, -1)).join(''))]
   }
 }
 
-// instantiation time const initializer
-const consumeConst = (node, ctx) => {
+// serialize binary array
+const vec = a => [...uleb(a.length), ...a]
+
+// instantiation time const initializer (consuming)
+const expr = (node, ctx) => {
   let op = node.shift(), [type, cmd] = op.split('.')
 
   // (global.get idx)
-  if (type === 'global') return [0x23, ...uleb(node[0][0] === '$' ? ctx.global[node[0]] : node[0])]
+  if (type === 'global') return [0x23, ...uleb(node[0][0] === '$' ? ctx.global[node[0]] : +node)]
 
   // (v128.const i32x4 1 2 3 4)
   if (type === 'v128') return [0xfd, 0x0c, ...v128(node)]
@@ -407,11 +538,19 @@ const consumeConst = (node, ctx) => {
   // (i32.const 1)
   if (cmd === 'const') return [0x41 + ['i32', 'i64', 'f32', 'f64'].indexOf(type), ...encode[type](node[0])]
 
+  // (ref.func $x) or (ref.null func|extern)
+  if (type === 'ref') {
+    return cmd === 'func' ?
+      [0xd2, ...uleb(node[0][0] === '$' ? ctx.func[node[0]] : +node)] :
+      // heaptype
+      [0xd0, TYPE[node[0] + 'ref']] // func->funcref, extern->externref
+  }
+
   // (i32.add a b), (i32.mult a b) etc
   return [
-    ...consumeConst(node.shift(), ctx),
-    ...consumeConst(node.shift(), ctx),
-    OP.indexOf(op)
+    ...expr(node.shift(), ctx),
+    ...expr(node.shift(), ctx),
+    INSTR[op]
   ]
 }
 
@@ -440,6 +579,62 @@ const v128 = (args) => {
   return arr
 }
 
+// https://webassembly.github.io/spec/core/text/modules.html#type-uses
+// consume (type $id|id) (param t+)* (result t+)*
+const typeuse = (nodes, ctx) => {
+  let idx, param, result, alias
+
+  // existing/new type (type 0|$name)
+  if (nodes[0]?.[0] === 'type') {
+    [, idx] = nodes.shift();
+
+    // (type 0), (type $n) - existing type
+    if (ctx.type[idx] != null) {
+      paramres(nodes);
+      if (idx[0] === '$') idx = ctx.type[idx];
+      ({ param, result } = ctx.type[idx] ?? err('Bad type ' + idx));
+      return [+idx, param, result]
+    }
+  }
+
+  // if new type - find existing match
+  ;[param, result] = paramres(nodes), alias = param + '>' + result
+  // or register new type
+  if (ctx.type[alias] == null) {
+    build.type(ctx.type.length, [[, ['param', ...param], ['result', ...result]]], ctx)
+  }
+
+  return [ctx.type[alias], param, result]
+}
+
+// consume (param t+)* (result t+)* sequence
+const paramres = (nodes) => {
+  let param = [], result = []
+
+  // collect param (param i32 i64) (param $x? i32)
+  while (nodes[0]?.[0] === 'param') {
+    let [, ...args] = nodes.shift()
+    let name = args[0]?.[0] === '$' && args.shift()
+    if (name) param[name] = param.length // expose name refs
+    param.push(...args)
+  }
+
+  // collect result eg. (result f64 f32)(result i32)
+  while (nodes[0]?.[0] === 'result') {
+    let [, ...args] = nodes.shift()
+    result.push(...args)
+  }
+
+  return [param, result]
+}
+
+// consume align/offset/etc params
+const memarg = (args) => {
+  let ao = {}, kv
+  while (args[0]?.includes('=')) kv = args.shift().split('='), ao[kv[0]] = Number(kv[1])
+  return ao
+}
+
 // escape codes
 const escape = { n: 10, r: 13, t: 9, v: 1, '\\': 92 }
 
@@ -447,48 +642,16 @@ const escape = { n: 10, r: 13, t: 9, v: 1, '\\': 92 }
 const str = str => {
   str = str[0] === '"' ? str.slice(1, -1) : str
   let res = [], i = 0, c, BSLASH = 92
-  // spec https://webassembly.github.io/spec/core/text/values.html#strings
+  // https://webassembly.github.io/spec/core/text/values.html#strings
   for (; i < str.length;) {
     c = str.charCodeAt(i++)
     res.push(c === BSLASH ? escape[str[i++]] || parseInt(str.slice(i - 1, ++i), 16) : c)
   }
 
-  res.unshift(...uleb(res.length))
-  return res
+  return vec(res)
 }
 
-// build range/limits sequence (non-consuming)
-const range = ([min, max, shared]) => isNaN(parseInt(max)) ? [0, ...uleb(min)] : [shared === 'shared' ? 3 : 1, ...uleb(min), ...uleb(max)]
-
-// get type info from (params) (result) nodes sequence (consumes nodes)
-// returns registered (reused) type idx, params bytes, result bytes
-// eg. (type $return_i32 (func (result i32)))
-const consumeType = (nodes, ctx) => {
-  let params = [], result = [], idx, bytes
-
-  // collect params
-  while (nodes[0]?.[0] === 'param') {
-    let [, ...types] = nodes.shift()
-    if (types[0]?.[0] === '$') params[types.shift()] = params.length
-    params.push(...types.map(t => TYPE[t]))
-  }
-
-  // collect result type
-  if (nodes[0]?.[0] === 'result') result = nodes.shift().slice(1).map(t => TYPE[t])
+// build limits sequence (non-consuming)
+const limits = ([min, max, shared]) => isNaN(parseInt(max)) ? [0, ...uleb(min)] : [shared === 'shared' ? 3 : 1, ...uleb(min), ...uleb(max)]
 
-  // reuse existing type or register new one
-  bytes = [TYPE.func, ...uleb(params.length), ...params, ...uleb(result.length), ...result]
-  idx = ctx.type.findIndex((t) => t.every((byte, i) => byte === bytes[i]))
-
-  // register new type, if not found
-  if (idx < 0) idx = ctx.type.push(bytes) - 1
-
-  return [idx, params, result]
-}
-
-// 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
-}
+const err = text => { throw Error(text) }

package/src/const.js

@@ -1,18 +1,16 @@
-// 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', , , , , , , , ,
-  'drop', 'select', , , , ,
-  'local.get', 'local.set', 'local.tee', 'global.get', 'global.set', , , ,
-  'i32.load', 'i64.load', 'f32.load', 'f64.load',
-  'i32.load8_s', 'i32.load8_u', 'i32.load16_s', 'i32.load16_u',
-  'i64.load8_s', 'i64.load8_u', 'i64.load16_s', 'i64.load16_u', 'i64.load32_s', 'i64.load32_u',
-  'i32.store', 'i64.store', 'f32.store', 'f64.store',
-  'i32.store8', 'i32.store16', 'i64.store8', 'i64.store16', 'i64.store32',
+// https://webassembly.github.io/spec/core/appendix/index-instructions.html
+export const INSTR = [
+  'unreachable', 'nop', 'block:b', 'loop:b', 'if:b', 'else', 'then', , , , ,
+  'end', 'br:i', 'br_if:i', 'br_table:i*', 'return', 'call:i', 'call_indirect:i:i', , , , , , , , ,
+  'drop', 'select', 'select2:t', , , ,
+  'local.get:i', 'local.set:i', 'local.tee:i', 'global.get:i', 'global.set:i', 'table.get:i', 'table.set:i', ,
+  'i32.load:m', 'i64.load:m', 'f32.load:m', 'f64.load:m',
+  'i32.load8_s:m', 'i32.load8_u:m', 'i32.load16_s:m', 'i32.load16_u:m',
+  'i64.load8_s:m', 'i64.load8_u:m', 'i64.load16_s:m', 'i64.load16_u:m', 'i64.load32_s:m', 'i64.load32_u:m',
+  'i32.store:m', 'i64.store:m', 'f32.store:m', 'f64.store:m',
+  'i32.store8:m', 'i32.store16:m', 'i64.store8:m', 'i64.store16:m', 'i64.store32:m',
   'memory.size', 'memory.grow',
-  'i32.const', 'i64.const', 'f32.const', 'f64.const',
+  'i32.const:n', 'i64.const:n', 'f32.const:n', 'f64.const:n',
   'i32.eqz', 'i32.eq', 'i32.ne', 'i32.lt_s', 'i32.lt_u', 'i32.gt_s', 'i32.gt_u', 'i32.le_s', 'i32.le_u', 'i32.ge_s', 'i32.ge_u',
   'i64.eqz', 'i64.eq', 'i64.ne', 'i64.lt_s', 'i64.lt_u', 'i64.gt_s', 'i64.gt_u', 'i64.le_s', 'i64.le_u', 'i64.ge_s', 'i64.ge_u',
   'f32.eq', 'f32.ne', 'f32.lt', 'f32.gt', 'f32.le', 'f32.ge',
@@ -26,19 +24,29 @@ export const OP = [
   'i64.trunc_f32_s', 'i64.trunc_f32_u', 'i64.trunc_f64_s', 'i64.trunc_f64_u',
   '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', ,
+  'i32.reinterpret_f32', 'i64.reinterpret_f64', 'f32.reinterpret_i32', 'f64.reinterpret_i64',
+  'i32.extend8_s', 'i32.extend16_s', 'i64.extend8_s', 'i64.extend16_s', 'i64.extend32_s', , , , , , , , , , , ,
+  'ref.null:t', 'ref.is_null', 'ref.func:i', , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
 
-  // 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"
+  // 0xFC 0xNN (0xfc shift)
+  'i32.trunc_sat_f32_u', 'i32.trunc_sat_f32_u', 'i32.trunc_sat_f64_s', 'i32.trunc_sat_f64_u', 'i64.trunc_sat_f32_s', 'i64.trunc_sat_f32_u', 'i64.trunc_sat_f64_s', 'i64.trunc_sat_f64_u',
+  'memory.init:i', 'data.drop:i', 'memory.copy', 'memory.fill', 'table.init:i:i', 'elem.drop:i', 'table.copy:i:i', 'table.grow:i', 'table.size:i', 'table.fill:i', ,
+
+  // 0xFD 0xNN (0x10f shift)
+  'v128.load:m', 'v128.load8x8_s:m', 'v128.load8x8_u:m', 'v128.load16x4_s:m', 'v128.load16x4_u:m', 'v128.load32x2_s:m', 'v128.load32x2_u:m', 'v128.load8_splat:m', 'v128.load16_splat:m', 'v128.load32_splat:m', 'v128.load64_splat:m', 'v128.store:m', 'v128.const:n', 'i8x16.shuffle:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n',
+  'i8x16.swizzle', 'i8x16.splat', 'i16x8.splat', 'i32x4.splat', 'i64x2.splat', 'f32x4.splat', 'f64x2.splat',
+  'i8x16.extract_lane_s:n', 'i8x16.extract_lane_u:n', 'i8x16.replace_lane:n', 'i16x8.extract_lane_s:n', 'i16x8.extract_lane_u:n', 'i16x8.replace_lane:n', 'i32x4.extract_lane:n', 'i32x4.replace_lane:n', 'i64x2.extract_lane:n', 'i64x2.replace_lane:n', 'f32x4.extract_lane:n', 'f32x4.replace_lane:n', 'f64x2.extract_lane:n', 'f64x2.replace_lane:n',
+  '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:m:l', 'v128.load16_lane:m:l', 'v128.load32_lane:m:l', 'v128.load64_lane:m:l', 'v128.store8_lane', 'v128.store16_lane', 'v128.store32_lane', 'v128.store64_lane', 'v128.load32_zero:m', 'v128.load64_zero:m', '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, v128: 0x7B },
+  SECTION = { custom: 0, type: 1, import: 2, func: 3, table: 4, memory: 5, global: 6, export: 7, start: 8, elem: 9, code: 10, data: 11, datacount: 12 },
+  TYPE = { i32: 0x7f, i64: 0x7e, f32: 0x7d, f64: 0x7c, void: 0x40, v128: 0x7B, func: 0x60, funcref: 0x70, externref: 0x6F, extern: 0x6f },
   KIND = { func: 0, table: 1, memory: 2, global: 3 },
+  // FIXME: replace with formula
   ALIGN = {
     'i32.load': 4, 'i64.load': 8, 'f32.load': 4, 'f64.load': 8,
     'i32.load8_s': 1, 'i32.load8_u': 1, 'i32.load16_s': 2, 'i32.load16_u': 2,
@@ -49,8 +57,5 @@ export const OP = [
     '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
+    '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
   }

package/src/encode.js

@@ -2,6 +2,7 @@
 
 // uleb
 export const uleb = (n, buffer = []) => {
+  if (n == null) return buffer
   if (typeof n === 'string') n = i32.parse(n)
 
   let byte = n & 0b01111111;

package/src/util.js

@@ -1 +0,0 @@
-export const err = text => { throw Error(text) }