watr 2.4.1 → 3.1.0

package/src/compile.js

@@ -1,494 +1,778 @@
 import * as encode from './encode.js'
 import { uleb } from './encode.js'
-import { OP, SECTION, ALIGN, TYPE, KIND } from './const.js'
+import { SECTION, TYPE, KIND, INSTR, HEAPTYPE, REFTYPE } from './const.js'
 import parse from './parse.js'
-import { err } from './util.js'
 
+// build instructions index
+INSTR.forEach((op, i) => INSTR[op] = i >= 0x11a ? [0xfd, i - 0x11a] : i >= 0xfc ? [0xfc, i - 0xfc] : [i]);
 
+// console.log(INSTR)
 /**
- * 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.
+ * @param {Object} opt - opt.fullSize for fixed-width uleb encoding
+ * @returns {Uint8Array} The compiled WASM binary data.
  */
-export default (nodes) => {
+export default function watr(nodes) {
+  // normalize to (module ...) form
   if (typeof nodes === 'string') nodes = parse(nodes);
+  else nodes = clone(nodes)
 
-  // 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 = [
-    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]]
+  // module abbr https://webassembly.github.io/spec/core/text/modules.html#id10
+  if (nodes[0] === 'module') nodes.shift(), nodes[0]?.[0] === '$' && nodes.shift()
+  // single node, not module
+  else if (typeof nodes[0] === 'string') nodes = [nodes]
+
+  // binary abbr "\00" "\0x61" ...
+  if (nodes[0] === 'binary') {
+    nodes.shift()
+    return Uint8Array.from(str(nodes.map(i => i.slice(1, -1)).join('')))
+  }
+  // quote "a" "b"
+  else if (nodes[0] === 'quote') {
+    nodes.shift()
+    return watr(nodes.map(i => i.slice(1, -1)).join(''))
+  }
+
+  // Scopes are stored directly on section array by key, eg. section.func.$name = idx
+  const sections = []
+  for (let kind in SECTION) (sections[SECTION[kind]] = sections[kind] = []).name = kind
+  sections._ = {} // implicit types
+
+  for (let [kind, ...node] of nodes) {
+    let imported // if node needs to be imported
+
+    // import abbr
+    // (import m n (table|memory|global|func id? type)) -> (table|memory|global|func id? (import m n) type)
+    if (kind === 'import') [kind, ...node] = (imported = node).pop()
+
+    // index, alias
+    let name = node[0]?.[0] === '$' && node.shift(), idx = sections[kind].length;
+    if (name) name in sections[kind] ? err(`Duplicate ${kind} ${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') sections.export.push([node.shift()[1], [kind, idx]])
+
+    // for import nodes - redirect output to import
+    if (node[0]?.[0] === 'import') [, ...imported] = node.shift()
+
+    // table abbr
+    if (kind === 'table') {
+      // (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]
+        sections.elem.push([['table', name || sections.table.length], ['i32.const', '0'], 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)
+    else if (kind === 'memory' && 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
+      sections.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 = []
+    // keep start name
+    else if (kind === 'start') name && node.push(name);
+
+    // [func, [param, result]] -> [param, result], alias
+    else if (kind === 'type') node[0].shift(), node = paramres(node[0]), sections.type['$' + node.join('>')] ??= idx
 
-  for (let name of order) {
-    let remaining = []
-    for (let node of nodes) {
-      node[0] === name ? postcall.push(build[name](node, sections)) : remaining.push(node)
+    // dupe to code section, save implicit type
+    else if (kind === 'func') {
+      let [idx, param, result] = typeuse(node, sections);
+      idx ?? (sections._[idx = '$' + param + '>' + result] = [param, result]);
+      !imported && nodes.push(['code', [idx, param, result], ...plain(node, sections)]) // pass param since they may have names
+      node.unshift(['type', idx])
     }
-    nodes = remaining
+
+    // import writes to import section amd adds placeholder for (kind) section
+    if (imported) sections.import.push([...imported, [kind, ...node]]), node = null
+
+    sections[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)
+  // add implicit types - main types receive aliases, implicit types are added if no explicit types exist
+  for (let n in sections._) sections.type[n] ??= sections.type.push(sections._[n]) - 1
+
+  // patch datacount if data === 0
+  if (!sections.data.length) sections.datacount.length = 0
+
+  // convert nodes to bytes
+  const bin = (kind, count = true) => {
+    let items = sections[kind].filter(Boolean).map(item => build[kind](item, sections))
+    return !items.length ? [] : [kind, ...vec(count ? vec(items) : items)]
   }
 
-  return new Uint8Array(binary)
+  // build final binary
+  return Uint8Array.from([
+    0x00, 0x61, 0x73, 0x6d, // magic
+    0x01, 0x00, 0x00, 0x00, // version
+    ...bin(SECTION.custom),
+    ...bin(SECTION.type),
+    ...bin(SECTION.import),
+    ...bin(SECTION.func),
+    ...bin(SECTION.table),
+    ...bin(SECTION.memory),
+    ...bin(SECTION.global),
+    ...bin(SECTION.export),
+    ...bin(SECTION.start, false),
+    ...bin(SECTION.elem),
+    ...bin(SECTION.datacount, false),
+    ...bin(SECTION.code),
+    ...bin(SECTION.data)
+  ])
 }
 
-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
-  },
+// abbr blocks, loops, ifs; collect implicit types via typeuses; resolve optional immediates
+// https://webassembly.github.io/spec/core/text/instructions.html#folded-instructions
+const plain = (nodes, ctx) => {
+  let out = []
 
-  // (func $name? ...params result ...body)
-  func([, ...body], ctx) {
-    let locals = [], // list of local variables
-      blocks = [] // control instructions / blocks stack
+  while (nodes.length) {
+    let node = nodes.shift()
 
-    // fn name
-    if (body[0]?.[0] === '$') ctx.func[body.shift()] = ctx.func.length
+    if (typeof node === 'string') {
+      out.push(node)
 
-    // export binding
-    if (body[0]?.[0] === 'export') build.export([...body.shift(), ['func', ctx.func.length]], ctx)
+      if (abbr[node]) out.push(...abbr[node](nodes, ctx))
+    }
 
-    // register/consume type info
-    let [typeIdx, params, result] = consumeType(body, ctx)
+    // FIXME: try to move this to abbr
+    else {
+      node = plain(node, ctx)
 
-    // register new function
-    ctx.func.push([typeIdx])
+      // (block ...) -> block ... end
+      if (node[0] === 'block' || node[0] === 'loop') {
+        out.push(...node, 'end')
+      }
 
-    // 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
-      locals.push(...types.map(t => TYPE[t]))
-    }
+      // (if ...) -> if ... end
+      else if (node[0] === 'if') {
+        let thenelse = [], blocktype = [node.shift()]
+        // (if label? blocktype? cond*? (then instr*) (else instr*)?) -> cond*? if label? blocktype? instr* else instr*? end
+        // https://webassembly.github.io/spec/core/text/instructions.html#control-instructions
+        if (node[node.length - 1]?.[0] === 'else') thenelse.unshift(...node.pop())
+        if (node[node.length - 1]?.[0] === 'then') thenelse.unshift(...node.pop())
 
-    // squash local types
-    let locTypes = locals.reduce((a, type) => (type == a[a.length - 1] ? a[a.length - 2]++ : a.push(1, type), a), [])
+        // label?
+        if (node[0]?.[0] === '$') blocktype.push(node.shift())
 
-    // convert sequence of instructions from input nodes to out bytes
-    const consume = (nodes, out = []) => {
-      if (!nodes?.length) return out
+        // blocktype? - (param) are removed already via plain
+        if (node[0]?.[0] === 'type' || node[0]?.[0] === 'result') blocktype.push(node.shift());
 
-      let op = nodes.shift(), opCode, args = nodes, immed, id, group
+        // ignore empty else
+        // https://webassembly.github.io/spec/core/text/instructions.html#abbreviations
+        if (thenelse[thenelse.length - 1] === 'else') thenelse.pop()
 
-      // groups are flattened, eg. (cmd z w) -> z w cmd
-      if (group = Array.isArray(op)) {
-        args = [...op] // op is immutable
-        opCode = OP.indexOf(op = args.shift())
-      }
-      else opCode = OP.indexOf(op)
-
-      // 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()))
-        }
-        // (i8x16.shuffle 0 1 ... 15 a b)
-        else if (opCode === 0x0d) {
-          // i8, i16, i32 - bypass the encoding
-          for (let i = 0; i < 16; i++) immed.push(encode.i32.parse(args.shift()))
-        }
-        // (v128.const i32x4)
-        else if (opCode === 0x0c) {
-          args.unshift(op)
-          immed = consumeConst(args, ctx)
-        }
-        // (i8x16.extract_lane_s 0 ...)
-        else if (opCode >= 0x15 && opCode <= 0x22) {
-          immed.push(...uleb(args.shift()))
-        }
-        opCode = null // ignore opcode
+        out.push(...node, ...blocktype, ...thenelse, 'end')
       }
+      else out.push(node)
+    }
+  }
 
-      // 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)]
-        // memory.init idx, memory.drop idx, table.init idx, table.drop idx
-        if (!(opCode & 0b10)) immed.push(...uleb(args.shift()))
-        else immed.push(0)
-        // even opCodes (memory.init, memory.copy, table.init, table.copy) have 2nd predefined immediate
-        if (!(opCode & 0b1)) immed.push(0)
-        opCode = null // ignore opcode
-      }
+  return out
+}
 
-      // binary/unary (i32.add a b) - no immed
-      else if (opCode >= 0x45) { }
+const abbr = {
+  // block typeuse?
+  block: (nodes, ctx) => {
+    let out = []
 
-      // (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 = consumeParams(args)
-        immed = [Math.log2(o.align ?? ALIGN[op]), ...uleb(o.offset ?? 0)]
-      }
+    // (loop $l?)
+    if (nodes[0]?.[0] === '$') out.push(nodes.shift())
 
-      // (i32.const 123), (f32.const 123.45) etc
-      else if (opCode >= 0x41 && opCode <= 0x44) {
-        immed = encode[op.split('.')[0]](args.shift())
-      }
+    let [idx, param, result] = typeuse(nodes, ctx, 0)
 
-      // (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())
-      }
+    // direct idx (no params/result needed)
+    if (idx != null) out.push(['type', idx])
+    // get type - can be either idx or valtype (numtype | reftype)
+    else if (!param.length && !result.length);
+    // (result i32) - doesn't require registering type
+    else if (!param.length && result.length === 1) out.push(['result', ...result])
+    // (param i32 i32)? (result i32 i32) - implicit type
+    else ctx._[idx = '$' + param + '>' + result] = [param, result], out.push(['type', idx])
 
-      // (global.get id), (global.set id)
-      else if (opCode == 0x23 || opCode == 36) {
-        immed = uleb(args[0]?.[0] === '$' ? ctx.global[args.shift()] : args.shift())
-      }
+    return out
+  },
+  loop: (nodes, ctx) => abbr.block(nodes, ctx),
+  if: (nodes, ctx) => abbr.block(nodes, ctx),
+
+  // select (result i32 i32 i32)?
+  select: (nodes, ctx) => [paramres(nodes, 0)[1]],
+
+  // call_indirect $table? $typeidx
+  // return_call_indirect $table? $typeidx
+  call_indirect: (nodes, ctx) => {
+    let tableidx = nodes[0]?.[0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0
+    let [idx, param, result] = typeuse(nodes, ctx, 0)
+    return [tableidx, ['type', idx ?? (ctx._[idx = '$' + param + '>' + result] = [param, result], idx)]]
+  },
+  return_call_indirect: (nodes, ctx) => abbr.call_indirect(nodes, ctx),
+
+  // else $label
+  else: (nodes, ctx) => (nodes[0]?.[0] === '$' && nodes.shift(), []),
+  // end $label
+  end: (nodes, ctx) => (nodes[0]?.[0] === '$' && nodes.shift(), []),
+
+  // mark datacount section as required
+  'memory.init': (nodes, ctx) => (ctx.datacount[0] = true, []),
+  'data.drop': (nodes, ctx) => (ctx.datacount[0] = true, []),
+
+  // table.init tableidx? elemidx -> table.init tableidx elemidx
+  'table.init': (nodes, ctx) => [(nodes[1][0] === '$' || !isNaN(nodes[1])) ? nodes.shift() : 0, nodes.shift()],
+
+  // table.* tableidx?
+  'table.get': (nodes, ctx) => [nodes[0]?.[0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0],
+  'table.set': (nodes, ctx) => abbr['table.get'](nodes, ctx),
+  'table.fill': (nodes, ctx) => abbr['table.get'](nodes, ctx),
+  'table.size': (nodes, ctx) => abbr['table.get'](nodes, ctx),
+  'table.grow': (nodes, ctx) => abbr['table.get'](nodes, ctx),
+  // table.copy tableidx? tableidx?
+  'table.copy': (nodes, ctx) => [...abbr['table.get'](nodes, ctx), nodes[0][0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0],
+}
 
-      // (call id ...nodes)
-      else if (opCode == 16) {
-        let fnName = args.shift()
-        immed = uleb(id = fnName[0] === '$' ? ctx.func[fnName] ?? err('Unknown function `' + fnName + '`') : fnName);
-        // FIXME: how to get signature of imported function
-      }
+// consume typeuse nodes, return type index/params, or null idx if no type
+// https://webassembly.github.io/spec/core/text/modules.html#type-uses
+const typeuse = (nodes, ctx, names) => {
+  let idx, param, result
 
-      // (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)
-      }
+  // explicit type (type 0|$name)
+  if (nodes[0]?.[0] === 'type') {
+    [, idx] = nodes.shift();
+    [param, result] = paramres(nodes, names);
 
-      // FIXME multiple memory (memory.grow $idx?)
-      else if (opCode == 63 || opCode == 64) {
-        immed = [0]
-      }
+    // check type consistency (excludes forward refs)
+    if ((param.length || result.length) && idx in ctx.type)
+      if (ctx.type[id(idx, ctx.type)].join('>') !== param + '>' + result) err(`Type ${idx} mismatch`)
 
-      // (block ...), (loop ...), (if ...)
-      else if (opCode === 2 || opCode === 3 || opCode === 4) {
-        blocks.push(opCode)
+    return [idx]
+  }
 
-        // (block $x) (loop $y)
-        if (opCode < 4 && args[0]?.[0] === '$') (blocks[args.shift()] = blocks.length)
+  // implicit type (param i32 i32)(result i32)
+  [param, result] = paramres(nodes, names)
 
-        // get type
-        // (result i32) - doesn't require registering type
-        if (args[0]?.[0] === 'result' && args[0].length < 3) {
-          let [, type] = args.shift()
-          immed = [TYPE[type]]
-        }
-        // (result i32 i32)
-        else if (args[0]?.[0] === 'result' || args[0]?.[0] === 'param') {
-          let [typeId] = consumeType(args, ctx)
-          immed = [typeId]
-        }
-        else {
-          immed = [TYPE.void]
-        }
+  return [, param, result]
+}
 
-        if (group) {
-          // (block xxx) -> block xxx end
-          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`
-          else {
-            nodes.unshift(args.pop())
-            // (if cond a b) -> (if cond a else b)
-            if (nodes[0][0] !== 'else') nodes.unshift('else')
-            // (if a b (else)) -> (if a b)
-            else if (nodes[0].length < 2) nodes.shift()
-            nodes.unshift(args.pop())
-          }
-        }
-      }
+// consume (param t+)* (result t+)* sequence
+const paramres = (nodes, names = true) => {
+  let param = [], result = []
 
-      // (else)
-      else if (opCode === 5) {
-        // (else xxx) -> else xxx
-        if (group) while (args.length) nodes.unshift(args.pop())
-      }
-      // (then)
-      else if (opCode === 6) {
-        opCode = null // ignore opcode
-      }
+  // collect param (param i32 i64) (param $x? i32)
+  while (nodes[0]?.[0] === 'param') {
+    let [, ...args] = nodes.shift()
+    args = args.map(t => t[0] === 'ref' && t[2] ? (HEAPTYPE[t[2]] ? (t[2]+t[0]) : t) : t); // deabbr
+    let name = args[0]?.[0] === '$' && args.shift()
+    // expose name refs, if allowed
+    if (name) names ? param[name] = param.length : err(`Unexpected param name ${name}`)
+    param.push(...args)
+  }
 
-      // (end)
-      else if (opCode == 0x0b) blocks.pop()
+  // collect result eg. (result f64 f32)(result i32)
+  while (nodes[0]?.[0] === 'result') {
+    let [, ...args] = nodes.shift()
+    args = args.map(t => t[0] === 'ref' && t[2] ? (HEAPTYPE[t[2]] ? (t[2]+t[0]) : t) : t); // deabbr
+    result.push(...args)
+  }
 
-      // (br $label result?)
-      // (br_if $label cond result?)
-      else if (opCode == 0x0c || opCode == 0x0d) {
-        // br index indicates how many block items to pop
-        immed = uleb(args[0]?.[0] === '$' ? blocks.length - blocks[args.shift()] : args.shift())
-      }
+  if (nodes[0]?.[0] === 'param') err(`Unexpected param`)
 
-      // (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))
-        immed.unshift(...uleb(immed.length - 1))
-      }
-      else if (opCode < 0) err(`Unknown instruction \`${op}\``)
+  return [param, result]
+}
 
-      // 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)
-      }
+// build section binary [by section codes] (non consuming)
+const build = [,
+  // (type $id? (func params result))
+  ([param, result], ctx) => ([0x60, ...vec(param.map(t => type(t, ctx))), ...vec(result.map(t => type(t, ctx)))]),
 
-      if (opCode) out.push(opCode)
-      if (immed) out.push(...immed)
-    }
+  // (import "math" "add" (func|table|global|memory typedef?))
+  ([mod, field, [kind, ...dfn]], ctx) => {
+    let details
 
-    // 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])
+    if (kind[0] === 'f') {
+      // we track imported funcs in func section to share namespace, and skip them on final build
+      let [[, typeidx]] = dfn
+      details = uleb(id(typeidx, ctx.type))
+    }
+    else if (kind[0] === 'm') {
+      details = limits(dfn)
+    }
+    else if (kind[0] === 'g') {
+      let [t] = dfn, mut = t[0] === 'mut' ? 1 : 0
+      details = [...type(mut ? t[1] : t, ctx), mut]
+    }
+    else if (kind[0] === 't') {
+      details = [...type(dfn.pop(), ctx), ...limits(dfn)]
     }
-  },
 
-  // (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))
+    return ([...vec(str(mod.slice(1, -1))), ...vec(str(field.slice(1, -1))), KIND[kind], ...details])
   },
 
-  // (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])
-  },
+  // (func $name? ...params result ...body)
+  ([[, typeidx]], ctx) => (uleb(id(typeidx, ctx.type))),
 
-  // (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])
+  // (table 1 2 funcref)
+  (node, ctx) => {
+    let lims = limits(node), t = type(node.shift(), ctx), [init] = node
+    return init ? [0x40, 0x00, ...t, ...lims, ...expr(init, ctx)]  : [...t, ...lims]
   },
 
-  // (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))])
-  },
+  // (memory id? export* min max shared)
+  (node, ctx) => limits(node),
 
-  //  (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)])
+  // (global $id? (mut i32) (i32.const 42))
+  (node, ctx) => {
+    let [t] = node, mut = t[0] === 'mut' ? 1 : 0
+
+    let [, init] = node
+    return ([...type(mut ? t[1] : t, ctx), mut, ...expr(init, ctx)])
   },
 
-  // (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();
+  //  (export "name" (func|table|mem $name|idx))
+  ([nm, [kind, l]], ctx) => ([...vec(str(nm.slice(1, -1))), KIND[kind], ...uleb(id(l, ctx[kind]))]),
 
-    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
+  // (start $main)
+  ([l], ctx) => uleb(id(l, ctx.func)),
+
+  // (elem elem*) - passive
+  // (elem declare elem*) - declarative
+  // (elem (table idx)? (offset expr)|(expr) elem*) - active
+  // elems := funcref|externref (item expr)|expr (item expr)|expr
+  // idxs := func? $id0 $id1
+  // ref: https://webassembly.github.io/spec/core/binary/modules.html#element-section
+  (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 = id(tabidx, ctx.table)
+      // ignore table=0
+      if (tabidx) mode |= 0b010
     }
-    else if (kind === 'memory') {
-      if (name) ctx.memory[name] = ctx.memory.length
-      details = range(parts)
+
+    // (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 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 mode |= 0b001 // passive
+
+    // func ... === funcref ..., https://webassembly.github.io/function-references/core/text/modules.html#id7
+    if (HEAPTYPE[parts[0]]) parts[0] += 'ref'
+    // reftype: funcref|externref|(ref ...)
+    if (parts[0] === 'funcref' || parts[0] === 'externref' || parts[0]?.[0] === 'ref') reftype = parts.shift()
+
+    // legacy abbr if func is skipped
+    if (!reftype) !tabidx ? reftype = 'funcref' : err(`Undefined reftype`)
+
+    // externref makes explicit table index
+    if (reftype === 'externref' || reftype[0] === 'ref') offset ||= ['i32.const', 0], mode = 0b110
+    // reset to simplest mode if no actual elements
+    else if (!parts.length) mode &= 0b011
+
+    // simplify els sequence
+    parts = parts.map(el => {
+      if (el[0] === 'item') [, ...el] = el
+      if (el[0] === 'ref.func') [, el] = el
+      // (ref.null func) and other expressions turn expr init mode
+      if (typeof el !== 'string') mode |= 0b100
+      return el
+    })
+
+    return ([
+      mode,
+      ...(
+        // 0b000 e:expr y*:vec(funcidx)                     | type=funcref, init ((ref.func y)end)*, active (table=0,offset=e)
+        mode === 0b000 ? expr(offset, ctx) :
+          // 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, ctx), 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) :
+                  // 0b101 et:reftype el*:vec(expr)                   | type=et, init el*, passive
+                  mode === 0b101 ? type(reftype, ctx) :
+                    // 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, ctx), ...type(reftype, ctx)] :
+                      // 0b111 et:reftype el*:vec(expr)                   | type=et, init el*, passive declare
+                      type(reftype, ctx)
+      ),
+      ...vec(
+        parts.map(mode & 0b100 ?
+          // ((ref.func y)end)*
+          el => expr(typeof el === 'string' ? ['ref.func', el] : el, ctx) :
+          // el*
+          el => uleb(id(el, ctx.func))
+        )
+      )
+    ])
+  },
+
+  // (code)
+  (body, ctx) => {
+    let [typeidx, param] = body.shift()
+    if (!param) [param] = ctx.type[id(typeidx, ctx.type)]
+
+    // provide param/local in ctx
+    ctx.local = Object.create(param) // list of local variables - some of them are params
+    ctx.block = [] // control instructions / blocks stack
+
+    // display names for error messages
+    ctx.local.name = 'local'
+    ctx.block.name = 'block'
+
+    // collect locals
+    while (body[0]?.[0] === 'local') {
+      let [, ...types] = body.shift()
+      if (types[0]?.[0] === '$') ctx.local[types.shift()] = ctx.local.length
+      ctx.local.push(...types)
     }
-    else throw Error('Unimplemented ' + kind)
 
-    ctx.import.push([...str(mod), ...str(field), KIND[kind], ...details])
+    const bytes = []
+    while (body.length) bytes.push(...instr(body, ctx))
+    bytes.push(0x0b)
+
+    // squash locals into (n:u32 t:valtype)*, n is number and t is type
+    // we skip locals provided by params
+    let loctypes = ctx.local.slice(param.length).reduce((a, type) => (type == a[a.length - 1]?.[1] ? a[a.length - 1][0]++ : a.push([1, type]), a), [])
+
+    // cleanup tmp state
+    ctx.local = ctx.block = null
+
+    // https://webassembly.github.io/spec/core/binary/modules.html#code-section
+    return vec([...vec(loctypes.map(([n, t]) => [...uleb(n), ...type(t, ctx)])), ...bytes])
   },
 
   // (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
+  (inits, ctx) => {
+    let offset, memidx = 0
+
+    // (memory ref)?
+    if (inits[0]?.[0] === 'memory') {
+      [, memidx] = inits.shift()
+      memidx = id(memidx, ctx.memory)
+    }
 
-    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]
+    // (offset (i32.const 0)) or (i32.const 0)
+    if (typeof inits[0] !== 'string') {
+      offset = inits.shift()
+      if (offset[0] === 'offset') [, offset] = offset
+      offset ?? err('Bad offset', offset)
+    }
 
-    ctx.data.push([0, ...consumeConst([...offset], ctx), 0x0b, ...str(inits.map(i => i[0] === '"' ? i.slice(1, -1) : i).join(''))])
+    return ([
+      ...(
+        // active: 2, x=memidx, e=expr
+        memidx ? [2, ...uleb(memidx), ...expr(offset, ctx)] :
+          // active: 0, e=expr
+          offset ? [0, ...expr(offset, ctx)] :
+            // passive: 1
+            [1]
+      ),
+      ...vec(str(inits.map(i => i.slice(1, -1)).join('')))
+    ])
   },
 
-  // (start $main)
-  start([, name], ctx) {
-    if (!ctx.start.length) ctx.start.push([name[0] === '$' ? ctx.func[name] : name])
+  // datacount
+  (nodes, ctx) => uleb(ctx.data.length)
+]
+
+// insert type, either direct or ref type
+const type = (t, ctx) =>
+  t[0] === 'ref' ? ([t[1] == 'null' ? TYPE.refnull : TYPE.ref, ...uleb(TYPE[t[t.length - 1]] || id(t[t.length - 1], ctx.type))])
+    : [TYPE[t] ?? err(`Unknown type ${t}`)]
+
+// consume one instruction from nodes sequence
+const instr = (nodes, ctx) => {
+  if (!nodes?.length) return []
+
+  let out = [], op = nodes.shift(), immed, code
+
+  // consume group
+  if (Array.isArray(op)) {
+    immed = instr(op, ctx)
+    while (op.length) out.push(...instr(op, ctx))
+    out.push(...immed)
+    return out
   }
-}
 
-// instantiation time const initializer
-const consumeConst = (node, ctx) => {
-  let op = node.shift(), [type, cmd] = op.split('.')
+  [...immed] = isNaN(op[0]) && INSTR[op] || err(`Unknown instruction ${op}`)
+  code = immed[0]
+
+  // v128s: (v128.load x) etc
+  // https://github.com/WebAssembly/simd/blob/master/proposals/simd/BinarySIMD.md
+  if (code === 0xfd) {
+    [, code] = immed
+    immed = [0xfd, ...uleb(code)]
+    // (v128.load)
+    if (code <= 0x0b) {
+      const [a, o] = memarg(nodes)
+      immed.push(...uleb((a ?? align(op))), ...uleb(o ?? 0))
+    }
+    // (v128.load_lane offset? align? idx)
+    else if (code >= 0x54 && code <= 0x5d) {
+      const [a, o] = memarg(nodes)
+      immed.push(...uleb((a ?? align(op))), ...uleb(o ?? 0))
+      // (v128.load_lane_zero)
+      if (code <= 0x5b) immed.push(...uleb(nodes.shift()))
+    }
+    // (i8x16.shuffle 0 1 ... 15 a b)
+    else if (code === 0x0d) {
+      // i8, i16, i32 - bypass the encoding
+      for (let i = 0; i < 16; i++) immed.push(encode.i32.parse(nodes.shift()))
+    }
+    // (v128.const i32x4 1 2 3 4)
+    else if (code === 0x0c) {
+      let [t, n] = nodes.shift().split('x'), stride = t.slice(1) >>> 3 // i16 -> 2, f32 -> 4
+      n = +n
+      // i8, i16, i32 - bypass the encoding
+      if (t[0] === 'i') {
+        let arr = n === 16 ? new Uint8Array(16) : n === 8 ? new Uint16Array(8) : n === 4 ? new Uint32Array(4) : new BigInt64Array(2)
+        for (let i = 0; i < n; i++) {
+          arr[i] = encode[t].parse(nodes.shift())
+        }
+        immed.push(...(new Uint8Array(arr.buffer)))
+      }
+      // f32, f64 - encode
+      else {
+        let arr = new Uint8Array(16)
+        for (let i = 0; i < n; i++) arr.set(encode[t](nodes.shift()), i * stride)
+        immed.push(...arr)
+      }
+    }
+    // (i8x16.extract_lane_s 0 ...)
+    else if (code >= 0x15 && code <= 0x22) {
+      immed.push(...uleb(nodes.shift()))
+    }
+  }
 
-  // (global.get idx)
-  if (type === 'global') return [0x23, ...uleb(node[0][0] === '$' ? ctx.global[node[0]] : node[0])]
+  // bulk memory: (memory.init) (memory.copy) (data.drop) (memory.fill)
+  // table ops: (table.init|copy|grow|size|fill) (elem.drop)
+  // https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md#instruction-encoding
+  else if (code == 0xfc) {
+    [, code] = immed
 
-  // (v128.const i32x4 1 2 3 4)
-  if (type === 'v128') return [0xfd, 0x0c, ...v128(node)]
+    // memory.init idx, data.drop idx,
+    if (code === 0x08 || code === 0x09) {
+      immed.push(...uleb(id(nodes.shift(), ctx.data)))
+    }
 
-  // (i32.const 1)
-  if (cmd === 'const') return [0x41 + ['i32', 'i64', 'f32', 'f64'].indexOf(type), ...encode[type](node[0])]
+    // memory placeholders
+    if (code == 0x08 || code == 0x0b) immed.push(0)
+    else if (code === 0x0a) immed.push(0, 0)
 
-  // (i32.add a b), (i32.mult a b) etc
-  return [
-    ...consumeConst(node.shift(), ctx),
-    ...consumeConst(node.shift(), ctx),
-    OP.indexOf(op)
-  ]
-}
+    // elem.drop elemidx
+    if (code === 0x0d) {
+      immed.push(...uleb(id(nodes.shift(), ctx.elem)))
+    }
+    // table.init tableidx elemidx -> 0xfc 0x0c elemidx tableidx
+    else if (code === 0x0c) {
+      immed.push(...uleb(id(nodes[1], ctx.elem)), ...uleb(id(nodes.shift(), ctx.table)))
+      nodes.shift()
+    }
+    // table.* tableidx?
+    // abbrs https://webassembly.github.io/spec/core/text/instructions.html#id1
+    else if (code >= 0x0c && code < 0x13) {
+      immed.push(...uleb(id(nodes.shift(), ctx.table)))
+      // table.copy tableidx? tableidx?
+      if (code === 0x0e) immed.push(...uleb(id(nodes.shift(), ctx.table)))
+    }
+  }
+
+  // control block abbrs
+  // block ..., loop ..., if ...
+  else if (code === 2 || code === 3 || code === 4) {
+    ctx.block.push(code)
+
+    // (block $x) (loop $y)
+    if (nodes[0]?.[0] === '$') ctx.block[nodes.shift()] = ctx.block.length
+
+    let typeidx = nodes[0]?.[0] === 'type' && id(nodes.shift()[1], ctx.type)
+
+    let [param, result] = typeidx !== false ? ctx.type[typeidx] : nodes[0]?.[0] === 'result' ? [, [nodes.shift()[1]]] : []
+
+    // void
+    if (!param?.length && !result?.length) immed.push(TYPE.void)
+    // (result i32) - doesn't require registering type
+    else if (!param?.length && result.length === 1) immed.push(...type(result[0], ctx))
+    // (type idx)
+    else immed.push(...uleb(typeidx))
+  }
+  // else
+  else if (code === 5) { }
+  // then
+  else if (code === 6) immed = [] // ignore
+
+  // local.get $id, local.tee $id x
+  else if (code == 0x20 || code == 0x21 || code == 0x22) {
+    immed.push(...uleb(id(nodes.shift(), ctx.local)))
+  }
 
-// (v128.const i32x4 1 2 3 4)
-const v128 = (args) => {
-  let [t, n] = args.shift().split('x'),
-    stride = t.slice(1) >>> 3 // i16 -> 2, f32 -> 4
+  // global.get $id, global.set $id
+  else if (code == 0x23 || code == 0x24) {
+    immed.push(...uleb(id(nodes.shift(), ctx.global)))
+  }
+
+  // call $func ...nodes
+  // return_call $func
+  else if (code == 0x10 || code == 0x12) {
+    immed.push(...uleb(id(nodes.shift(), ctx.func)))
+  }
+
+  // call_indirect $table (type $typeName) ...nodes
+  // return_call_indirect $table (type $typeName) ... nodes
+  else if (code == 0x11 || code == 0x13) {
+    immed.push(
+      ...uleb(id(nodes[1][1], ctx.type)),
+      ...uleb(id(nodes.shift(), ctx.table))
+    ), nodes.shift()
+  }
 
-  n = +n
+  // call_ref $type
+  // return_call_ref $type
+  else if (code == 0x14 || code == 0x15) {
+    immed.push(...uleb(id(nodes.shift(), ctx.type)))
+  }
+
+  // end
+  else if (code == 0x0b) ctx.block.pop()
+
+  // br $label result?
+  // br_if $label cond result?
+  // br_on_null $l, br_on_non_null $l
+  else if (code == 0x0c || code == 0x0d || code == 0xd5 || code == 0xd6) {
+    // br index indicates how many block items to pop
+    let l = nodes.shift(), i = l?.[0] === '$' ? ctx.block.length - ctx.block[l] : +l
+    i <= ctx.block.length || err(`Bad label ${l}`)
+    immed.push(...uleb(i))
+  }
 
-  // i8, i16, i32 - bypass the encoding
-  if (t[0] === 'i') {
-    let arr = n === 16 ? new Uint8Array(16) : n === 8 ? new Uint16Array(8) : n === 4 ? new Uint32Array(4) : new BigInt64Array(2)
-    for (let i = 0; i < n; i++) {
-      arr[i] = encode[t].parse(args.shift())
+  // br_table 1 2 3 4  0  selector result?
+  else if (code == 0x0e) {
+    let args = []
+    while (nodes[0] && (!isNaN(nodes[0]) || nodes[0][0] === '$')) {
+      let l = nodes.shift(), i = l[0][0] === '$' ? ctx.block.length - ctx.block[l] : +l
+      i <= ctx.block.length || err(`Bad label ${l}`)
+      args.push(...uleb(i))
     }
-    return new Uint8Array(arr.buffer)
+    args.unshift(...uleb(args.length - 1))
+    immed.push(...args)
+  }
+
+  // select (result t+)
+  else if (code == 0x1b) {
+    let result = nodes.shift()
+    // 0x1b -> 0x1c
+    if (result.length) immed.push(immed.pop() + 1, ...vec(result.map(t => type(t, ctx))))
   }
 
-  // f32, f64 - encode
-  let arr = new Uint8Array(16)
-  for (let i = 0; i < n; i++) {
-    arr.set(encode[t](args.shift()), i * stride)
+  // ref.func $id
+  else if (code == 0xd2) {
+    immed.push(...uleb(id(nodes.shift(), ctx.func)))
   }
 
-  return arr
+  // ref.null func
+  else if (code == 0xd0) {
+    let t = nodes.shift()
+    immed.push(HEAPTYPE[t] || id(t, ctx.type)) // func->funcref, extern->externref
+  }
+
+  // binary/unary (i32.add a b) - no immed
+  else if (code >= 0x45) { }
+
+  // i32.store align=n offset=m
+  else if (code >= 0x28 && code <= 0x3e) {
+    let [a, o] = memarg(nodes)
+    immed.push(...uleb((a ?? align(op))), ...uleb(o ?? 0))
+  }
+
+  // i32.const 123, f32.const 123.45
+  else if (code >= 0x41 && code <= 0x44) {
+    immed.push(...encode[op.split('.')[0]](nodes.shift()))
+  }
+
+  // memory.grow|size $idx - mandatory 0x00
+  // https://webassembly.github.io/spec/core/binary/instructions.html#memory-instructions
+  else if (code == 0x3f || code == 0x40) {
+    immed.push(0)
+  }
+
+  // table.get $id
+  else if (code == 0x25 || code == 0x26) {
+    immed.push(...uleb(id(nodes.shift(), ctx.table)))
+  }
+
+  out.push(...immed)
+
+  return out
+}
+
+// instantiation time value initializer (consuming) - we redirect to instr
+const expr = (node, ctx) => [...instr([node], ctx), 0x0b]
+
+// consume align/offset params
+const memarg = (args) => {
+  let align, offset, k, v
+  while (args[0]?.includes('=')) [k, v] = args.shift().split('='), k === 'offset' ? offset = +v : k === 'align' ? align = +v : err(`Unknown param ${k}=${v}`)
+
+  if (offset < 0 || offset > 0xffffffff) err(`Bad offset ${offset}`)
+  if (align <= 0 || align > 0xffffffff) err(`Bad align ${align}`)
+  if (align) ((align = Math.log2(align)) % 1) && err(`Bad align ${align}`)
+  return [align, offset]
+}
+
+// deref id node to idx
+const id = (n, list) => (n = n[0] === '$' ? list[n] : !isNaN(n) && +n, n in list ? n : err(`Unknown ${list.name} ${n}`))
+
+// ref:
+// const 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,
+//   '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
+// }
+const align = (op) => {
+  let [group, opname] = op.split('.'); // v128.load8x8_u -> group = v128, opname = load8x8_u
+  let [lsize] = (opname[0] === 'l' ? opname.slice(4) : opname.slice(5)).split('_') // load8x8_u -> lsize = 8x8
+  let [size, x] = lsize ? lsize.split('x') : [group.slice(1)] // 8x8 -> size = 8
+  return Math.log2(x ? 8 : +size / 8)
 }
 
+// build limits sequence (consuming)
+const limits = (node) => isNaN(parseInt(node[1])) ? [0, ...uleb(node.shift())] : [node[2] === 'shared' ? 3 : 1, ...uleb(node.shift()), ...uleb(node.shift())]
+
 // escape codes
-const escape = { n: 10, r: 13, t: 9, v: 1, '\\': 92 }
+const escape = { n: 10, r: 13, t: 9, v: 1, '"': 34, "'": 39, '\\': 92 }
 
 // build string binary
 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
 }
 
-// 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)]
+// serialize binary array
+const vec = a => [...uleb(a.length), ...a.flat()]
 
-// 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
+const err = text => { throw Error(text) }
 
-  // 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])
-
-  // 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 clone = items => items.map(item => Array.isArray(item) ? clone(item) : item)