watr 1.4.1 → 2.1.0

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "watr",
-  "version": "1.4.1",
+  "version": "2.1.0",
   "description": "Ligth & fast WAT compiler",
   "main": "watr.js",
+  "exports": {
+    ".": "./watr.js",
+    "./parse": "./src/parse.js",
+    "./print": "./src/print.js",
+    "./compile": "./src/compile.js"
+  },
   "type": "module",
   "scripts": {
     "test": "node test"
@@ -16,11 +22,16 @@
   ],
   "keywords": [
     "wat",
+    "wasm",
+    "wat2wasm",
     "compiler",
-    "wabt"
+    "wabt",
+    "pretty-print",
+    "webassembly",
+    "wasm-text"
   ],
   "author": "Dmitry Iv",
-  "license": "ISC",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/audio-lab/watr/issues"
   },

package/readme.md

@@ -1,25 +1,16 @@
-# 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)
+# 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)
 
-> Light & fast WAT compiler.
+> Bare minimum wasm text compiler & formatter.
 
-Provides bare minimum WAT to WASM compilation.<br/>
-Useful as WASM API layer, eg. for hi-level languages or for dynamic (in-browser?) compilation.
-<!--, eg. [sonl](https://github.com/audio-lab/sonl). -->
+Light & fast alternative for [wat2wasm](https://github.com/AssemblyScript/wabt.js), useful for hi-level languages or dynamic (in-browser) compilation.<br>
 
 <!-- See [REPL](https://audio-lab.github.io/watr/repl.html).-->
 
-<!--
-&nbsp; | watr | wat-compiler | wabt
----|---|---|---
-Size (gzipped) | 2.8kb | 6kb | 300kb
-Performance (op/s) | 45000 | 2500 | 3100
--->
-
 &nbsp; | Size (gzipped) | Performance (op/s)
 ---|---|---
-watr | 3.8 kb | 1900
-[wat-compiler](https://github.com/stagas/wat-compiler) | 6 kb | 135
-[wabt](https://github.com/AssemblyScript/wabt.js) | 300 kb | 250
+watr | 3.8 kb | 5950
+[wat-compiler](https://github.com/stagas/wat-compiler) | 6 kb | 348
+[wabt](https://github.com/AssemblyScript/wabt.js) | 300 kb | 574
 
 ## Usage
 
@@ -43,32 +34,17 @@ double(108) // 216
 
 ## API
 
-### Parse
-
-Parser converts input Wasm text string to 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]]
-// ]
-```
-
 ### Compile
 
-Compiles Wasm tree or text into wasm binary. Lightweight alternative to [wabt/wat2wasm](https://github.com/WebAssembly/wabt).
+Compiles wasm text or syntax tree into wasm binary.
 
 ```js
 import { compile } from 'watr'
 
-const buffer = compile([
-  'func', ['export', '"double"'], ['param', 'f64'], ['result', 'f64'],
-  ['f64.mul', ['local.get', 0], ['f64.const', 2]]
-])
+const buffer = compile(`(func (export "double")
+  (param f64) (result f64)
+  (f64.mul (local.get 0) (f64.const 2))
+)`)
 const module = new WebAssembly.Module(buffer)
 const instance = new WebAssembly.Instance(module)
 const {double} = instance.exports
@@ -78,20 +54,20 @@ double(108) // 216
 
 ### Print
 
-Format input Wasm text string or tree into minified or pretty form.
+Format input wasm text or syntax tree into minified or pretty form.
 
 ```js
 import { print } from 'watr'
 
-const tree = [
-  'func', ['export', '"double"'], ['param', 'f64'], ['result', 'f64'],
-  ['f64.mul', ['local.get', 0], ['f64.const', 2]]
-]
+const src = `(func (export "double")
+  (param f64) (result f64)
+  (f64.mul (local.get 0) (f64.const 2))
+)`
 
 // pretty-print (default)
-const str = print(tree, {
-  indent: '  ',   // indentation chars
-  newline: '\n',  // new line chars
+print(src, {
+  indent: '  ',
+  newline: '\n',
 })
 // (func (export "double")
 //   (param f64) (result f64)
@@ -100,53 +76,34 @@ const str = print(tree, {
 //       (f64.const 2)))
 
 // minify
-const str = print(tree, {
+print(src, {
   indent: false,
   newline: false
 })
 // (func (export "double")(param f64)(result f64)(f64.mul (local.get 0)(f64.const 2)))
 ```
 
-<!--
-## Limitations
-
-It may miss some edge cases and nice error messages.
-For better REPL/dev experience use [wabt](https://github.com/AssemblyScript/wabt.js).
-
+### Parse
 
-Ambiguous syntax is prohibited in favor of explicit lispy notation. Each instruction must have prefix signature with parenthesized immediates and arguments.
+Parse input wasm text into syntax tree.
 
-```wast
-(func (result i32)
-  i32.const 1                 ;; ✘ stacked arguments
-  drop
-  i32.const 0
-  i32.load offset=0 align=4   ;; ✘ ungrouped immediates
-)
+```js
+import { parse } from 'watr'
 
-(func (result i32)
-  (drop (i32.const 1))                        ;; ✔ nested arguments
-  (i32.load offset=0 align=4 (i32.const 0))   ;; ✔ grouped immediates
-)
+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]]
+// ]
 ```
 
-```wast
-(local.get 0)     ;; ✘ stacked argument
-if (result i32)   ;; ✘ inline instruction
-  (i32.const 1)
-end
-
-(if (result i32) (local.get 0)  ;; ✔ explicit signature
-  (i32.const 1)
-)
-```
+## Limitations
 
-```wast
-(f32.const 0x1.fffffep+127)  ;; ✘ floating HEX - not supported
-```
--->
+No floating HEX support, eg. `(f32.const 0x1.fffffep+127)`.
 
+## Projects using watr
 
+* [auro](https://github.com/audio-lab/auro) – audio processing language
 
 ## Useful links
 
@@ -162,20 +119,19 @@ end
 * [wabt source search](https://github.com/WebAssembly/wabt/search?p=5&q=then)
 * [wat control flow](https://developer.mozilla.org/en-US/docs/WebAssembly/Reference/Control_flow)
 * [ontouchstart wasm book](https://ontouchstart.pages.dev/chapter_wasm_binary)
-* [wat-compiler](https://github.com/stagas/wat-compiler/)
 * [hackernoon](https://web.archive.org/web/20210215171830/https://hackernoon.com/webassembly-binary-format-explained-part-2-hj1t33yp?source=rss)
 * [webassemblyjs](https://github.com/xtuc/webassemblyjs)
 * [chasm](https://github.com/ColinEberhardt/chasm/blob/master/src/encoding.ts)
 * [WebBS](https://github.com/j-s-n/WebBS)
 * [leb128a](https://github.com/minhducsun2002/leb128/blob/master/src/index.ts)
 * [leb128b](https://github.com/shmishtopher/wasm-LEB128/tree/master/esm)
-
 -->
 
 ## Alternatives
 
 * [wabt](https://www.npmjs.com/package/wabt) − port of WABT for the web, de-facto standard.
 * [wat-compiler](https://www.npmjs.com/package/wat-compiler) − compact alternative for WABT, older brother of _watr_.
+* [wassemble](https://github.com/wingo/wassemble)
 * [web49](https://github.com/FastVM/Web49)
 
 <p align=center><a href="https://github.com/krsnzd/license/">🕉</a></p>

package/src/compile.js

@@ -2,8 +2,7 @@ import { uleb, leb, bigleb, f64, f32 } from './util.js'
 import { OP, SECTION, ALIGN, TYPE, KIND } from './const.js'
 import parse from './parse.js'
 
-// some inlinable instructions
-const INLINE = { loop: 1, block: 1, if: 1, end: -1, return: -1 }
+const OP_END = 0xb, OP_I32_CONST = 0x41, OP_I64_CONST = 0x42, OP_F32_CONST = 0x43, OP_F64_CONST = 0x44
 
 // convert wat tree to wasm binary
 export default (nodes) => {
@@ -43,13 +42,11 @@ export default (nodes) => {
     for (let node of nodes) {
       node[0] === name ? postcall.push(build[name](node, sections)) : remaining.push(node)
     }
-
     nodes = remaining
   }
 
   // code must be compiled after all definitions
-  for (let cb of postcall) cb && cb.call && cb()
-
+  for (let cb of postcall) cb?.()
 
   // 3. build binary
   for (let name in sections) {
@@ -69,37 +66,16 @@ 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, decl], ctx) {
-    if (typeName[0] !== '$') decl = typeName, typeName = null
-    let params = [], result = [], [kind, ...sig] = decl, idx, bytes
-
-    if (kind === 'func') {
-      // collect params
-      while (sig[0]?.[0] === 'param') {
-        let [, ...types] = sig.shift()
-        if (types[0]?.[0] === '$') params[types.shift()] = params.length
-        params.push(...types.map(t => TYPE[t]))
-      }
-
-      // collect result type
-      if (sig[0]?.[0] === 'result') result = sig.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((prevType) => prevType.every((byte, i) => byte === bytes[i]))
-      if (idx < 0) idx = ctx.type.push(bytes) - 1
-    }
-
+  type([, typeName, [kind, ...sig]], ctx) {
+    if (kind !== 'func') err(`Unknown type kind '${kind}'`)
+    const [idx] = consumeType(sig, ctx)
     if (typeName) ctx.type[typeName] = idx
-
-    return [idx, params, result]
   },
 
   // (func $name? ...params result ...body)
   func([, ...body], ctx) {
     let locals = [], // list of local variables
-      callstack = []
+      blocks = [] // control instructions / blocks stack
 
     // fn name
     if (body[0]?.[0] === '$') ctx.func[body.shift()] = ctx.func.length
@@ -107,10 +83,10 @@ const build = {
     // export binding
     if (body[0]?.[0] === 'export') build.export([...body.shift(), ['func', ctx.func.length]], ctx)
 
-    // register type
-    let [typeIdx, params, result] = build.type([, ['func', ...body]], ctx)
-    // FIXME: try merging with build.type: it should be able to consume body
-    while (body[0]?.[0] === 'param' || body[0]?.[0] === 'result') body.shift()
+    // register/consume type info
+    let [typeIdx, params, result] = consumeType(body, ctx)
+
+    // register new function
     ctx.func.push([typeIdx])
 
     // collect locals
@@ -125,164 +101,148 @@ const build = {
     // squash local types
     let locTypes = locals.reduce((a, type) => (type == a[a.length - 1] ? a[a.length - 2]++ : a.push(1, type), a), [])
 
-    // map code instruction into bytes: [args, opCode, immediates]
-    const instr = (group) => {
-      let [op, ...nodes] = group
-      let opCode = OP[op], argc = 0, before = [], after = [], id
-
-      // NOTE: we could reorganize ops by groups and detect signature as `op in STORE`
-      // but numeric comparison is faster than generic hash lookup
-      // FIXME: we often use OP.end or alike: what if we had list of global constants?
-
-      // binary/unary
-      if (opCode >= 69) {
-        argc = opCode >= 167 ||
-          (opCode <= 159 && opCode >= 153) ||
-          (opCode <= 145 && opCode >= 139) ||
-          (opCode <= 123 && opCode >= 121) ||
-          (opCode <= 105 && opCode >= 103) ||
-          opCode == 80 || opCode == 69 ? 1 : 2
-      }
-      // instruction
-      else {
-        // (i32.store align=n offset=m at value)
-        if (opCode >= 40 && opCode <= 62) {
-          // FIXME: figure out point in Math.log2 aligns
-          let o = { align: ALIGN[op], offset: 0 }, p
-          while (nodes[0]?.includes('=')) p = nodes.shift().split('='), o[p[0]] = Number(p[1])
-          after = [Math.log2(o.align), ...uleb(o.offset)]
-          argc = opCode >= 54 ? 2 : 1
-        }
+    // convert sequence of instructions from input nodes to out bytes
+    const consume = (nodes, out = []) => {
+      if (!nodes?.length) return out
 
-        // (i32.const 123)
-        else if (opCode >= 65 && opCode <= 68) {
-          after = (opCode == 65 ? leb : opCode == 66 ? bigleb : opCode == 67 ? f32 : f64)(nodes.shift())
-        }
+      let op = nodes.shift(), opCode, args = nodes, immed, id, group
 
-        // (local.get $id), (local.tee $id x)
-        else if (opCode >= 32 && opCode <= 34) {
-          after = uleb(nodes[0]?.[0] === '$' ? params[id = nodes.shift()] || locals[id] : nodes.shift())
-          if (opCode > 32) argc = 1
-        }
+      // 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)
 
-        // (global.get id), (global.set id)
-        else if (opCode == 35 || opCode == 36) {
-          after = uleb(nodes[0]?.[0] === '$' ? ctx.global[nodes.shift()] : nodes.shift())
-          if (opCode > 35) argc = 1
-        }
+      // NOTE: numeric comparison is faster than generic hash lookup
 
-        // (call id ...nodes)
-        else if (opCode == 16) {
-          let fnName = nodes.shift()
-          after = uleb(id = fnName[0] === '$' ? ctx.func[fnName] ?? err('Unknown function `' + fnName + '`') : fnName);
-          // FIXME: how to get signature of imported function
-          [, argc] = ctx.type[ctx.func[id][0]]
-        }
+      // binary/unary - just consume immed
+      if (opCode >= 69) { }
 
-        // (call_indirect (type $typeName) (idx) ...nodes)
-        else if (opCode == 17) {
-          let typeId = nodes.shift()[1];
-          [, argc] = ctx.type[typeId = typeId[0] === '$' ? ctx.type[typeId] : typeId]
-          argc++
-          after = uleb(typeId), after.push(0) // extra afterediate indicates table idx (reserved)
-        }
+      // (i32.store align=n offset=m at value)
+      else if (opCode >= 40 && opCode <= 62) {
+        // FIXME: figure out point in Math.log2 aligns
+        let o = { align: ALIGN[op], offset: 0 }, param
+        while (args[0]?.includes('=')) param = args.shift().split('='), o[param[0]] = Number(param[1])
+        immed = [Math.log2(o.align), ...uleb(o.offset)]
+      }
 
-        // FIXME (memory.grow $idx?)
-        else if (opCode == 63 || opCode == 64) {
-          after = [0]
-          argc = 1
-        }
+      // (i32.const 123)
+      else if (opCode >= 65 && opCode <= 68) {
+        immed = (opCode == 65 ? leb : opCode == 66 ? bigleb : opCode == 67 ? f32 : f64)(args.shift())
+      }
 
-        // (if (result i32)? (local.get 0) (then a b) (else a b)?)
-        else if (opCode == 4) {
-          callstack.push(opCode)
-          let [, type] = nodes[0][0] === 'result' ? nodes.shift() : [, 'void']
-          after = [TYPE[type]]
-
-          argc = 0, before.push(...instr(nodes.shift()))
-          let body
-          if (nodes[0]?.[0] === 'then') [, ...body] = nodes.shift(); else body = nodes
-          after.push(...consume(body))
-
-          callstack.pop(), callstack.push(OP.else)
-          if (nodes[0]?.[0] === 'else') {
-            [, ...body] = nodes.shift()
-            if (body.length) after.push(OP.else, ...consume(body))
-          }
-          callstack.pop()
-          after.push(OP.end)
-        }
+      // (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())
+      }
 
-        // (drop arg?), (return arg?)
-        else if (opCode == 0x1a || opCode == 0x0f) { argc = nodes.length ? 1 : 0 }
+      // (global.get id), (global.set id)
+      else if (opCode == 35 || opCode == 36) {
+        immed = uleb(args[0]?.[0] === '$' ? ctx.global[args.shift()] : args.shift())
+      }
 
-        // (select a b cond)
-        else if (opCode == 0x1b) { argc = 3 }
+      // (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
+      }
 
-        // (block ...), (loop ...)
-        else if (opCode == 2 || opCode == 3) {
-          callstack.push(opCode)
-          if (nodes[0]?.[0] === '$') (callstack[nodes.shift()] = callstack.length)
-          let [, type] = nodes[0]?.[0] === 'result' ? nodes.shift() : [, 'void']
-          after = [TYPE[type], ...consume(nodes)]
+      // (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)
+      }
 
-          if (!group.inline) callstack.pop(), after.push(OP.end) // inline loop/block expects end to be separately provided
-        }
+      // FIXME (memory.grow $idx?)
+      else if (opCode == 63 || opCode == 64) {
+        immed = [0]
+      }
 
-        // (end)
-        else if (opCode == 0x0b) callstack.pop()
+      // (if ...), (block ...), (loop ...)
+      else if (opCode > 1 && opCode < 5) {
+        blocks.push(opCode)
 
-        // (br $label result?)
-        // (br_if $label cond result?)
-        else if (opCode == 0x0c || opCode == 0x0d) {
-          // br index indicates how many callstack items to pop
-          after = uleb(nodes[0]?.[0] === '$' ? callstack.length - callstack[nodes.shift()] : nodes.shift())
-          argc = (opCode == 0x0d ? 1 + (nodes.length > 1) : !!nodes.length)
-        }
+        // (block $x) (loop $y)
+        if (opCode < 4 && args[0]?.[0] === '$') (blocks[args.shift()] = blocks.length)
 
-        // (br_table 1 2 3 4  0  selector result?)
-        else if (opCode == 0x0e) {
-          after = []
-          while (!Array.isArray(nodes[0])) id = nodes.shift(), after.push(...uleb(id[0][0] === '$' ? callstack.length - callstack[id] : id))
-          after.unshift(...uleb(after.length - 1))
-          argc = 1 + (nodes.length > 1)
+        // get type
+        // (result i32)
+        if (args[0]?.[0] === 'result') {
+          if (args[0].length < 3) {
+            let [, type] = args.shift()
+            immed = [TYPE[type]]
+          }
+          // (result i32 i32)
+          else {
+            let [typeId] = consumeType(args, ctx)
+            immed = [typeId]
+          }
+        }
+        else immed = [TYPE.void]
+
+        if (group) {
+          nodes.unshift('end')
+
+          // (block xxx) -> block xxx 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())
+          }
         }
+      }
 
-        else if (opCode == null) err(`Unknown instruction \`${op}\``)
+      // (else)
+      else if (opCode === 5) {
+        // (else xxx) -> else xxx
+        if (group) while (args.length) nodes.unshift(args.pop())
       }
 
-      // consume arguments
-      if (nodes.length < argc) err(`Stack arguments are not supported at \`${op}\``)
-      while (argc--) before.push(...instr(nodes.shift()))
-      if (nodes.length) err(`Too many arguments for \`${op}\`.`)
+      // (end)
+      else if (opCode == 0x0b) blocks.pop()
 
-      return [...before, opCode, ...after]
-    }
+      // (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())
+      }
 
-    // consume sequence of nodes
-    const consume = nodes => {
-      let result = []
-      while (nodes.length) {
-        let node = nodes.shift(), c
-
-        if (typeof node === 'string') {
-          // permit some inline instructions: loop $label ... end,  br $label,  arg return
-          if (c = INLINE[node]) {
-            node = [node], node.inline = true
-            if (c > 0) nodes[0]?.[0] === '$' && node.push(nodes.shift())
-          }
-          else err(`Inline instruction \`${node}\` is not supported`)
-        }
+      // (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))
+      }
 
-        node && result.push(...instr(node))
+      // 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)
       }
-      return result
+
+      // ignore (then) and other unknown instructions
+      if (opCode >= 0) out.push(opCode)
+      if (immed) out.push(...immed)
     }
 
-    // evaluates after all definitions
+    // evaluates after all definitions (need globals, elements, data etc.)
+    // FIXME: get rid of this postcall
     return () => {
-      let code = consume(body)
-      ctx.code.push([...uleb(code.length + 2 + locTypes.length), ...uleb(locTypes.length >> 1), ...locTypes, ...code, OP.end])
+      const bytes = []
+      while (body.length) consume(body, bytes)
+      ctx.code.push([...uleb(bytes.length + 2 + locTypes.length), ...uleb(locTypes.length >> 1), ...locTypes, ...bytes, OP_END])
     }
   },
 
@@ -337,7 +297,7 @@ const build = {
     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] = build.type([, ['func', ...parts]], ctx)
+      let [typeIdx] = consumeType(parts, ctx)
       ctx.func.push(details = uleb(typeIdx))
       ctx.func.importc = (ctx.func.importc || 0) + 1
     }
@@ -372,8 +332,8 @@ const build = {
 
 // (i32.const 0) - instantiation time initializer
 const iinit = ([op, literal], ctx) => op[0] === 'f' ?
-  [OP[op], ...(op[1] === '3' ? f32 : f64)(literal), OP.end] :
-  [OP[op], ...(op[1] === '3' ? leb : bigleb)(literal[0] === '$' ? ctx.global[literal] : literal), OP.end]
+  [op[1] === '3' ? OP_F32_CONST : OP_F64_CONST, ...(op[1] === '3' ? f32 : f64)(literal), OP_END] :
+  [op[1] === '3' ? OP_I32_CONST : OP_I64_CONST, ...(op[1] === '3' ? leb : bigleb)(literal[0] === '$' ? ctx.global[literal] : literal), OP_END]
 
 const escape = { n: 10, r: 13, t: 9, v: 1 }
 
@@ -391,8 +351,33 @@ const str = str => {
   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)]
 
+// 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])
+
+  // 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]
+}
+
 const err = text => { throw Error(text) }

package/src/const.js

@@ -1,10 +1,10 @@
 // ref: https://github.com/stagas/wat-compiler/blob/main/lib/const.js
 // NOTE: squashing into a string doesn't save up gzipped size
 export const OP = [
-  'unreachable', 'nop', 'block', 'loop', 'if', 'else', ,,,,,
-  'end', 'br', 'br_if', 'br_table', 'return', 'call', 'call_indirect', ,,,,,,,,
-  'drop', 'select', ,,,,
-  'local.get', 'local.set', 'local.tee', 'global.get', 'global.set', ,,,
+  'unreachable', 'nop', 'block', 'loop', 'if', 'else', , , , , ,
+  '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',
@@ -14,8 +14,8 @@ export const OP = [
   'i32.const', 'i64.const', 'f32.const', 'f64.const',
   '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',
-             'f64.eq', 'f64.ne', 'f64.lt',               'f64.gt',               'f64.le',               'f64.ge',
+  'f32.eq', 'f32.ne', 'f32.lt', 'f32.gt', 'f32.le', 'f32.ge',
+  'f64.eq', 'f64.ne', 'f64.lt', 'f64.gt', 'f64.le', 'f64.ge',
   'i32.clz', 'i32.ctz', 'i32.popcnt', 'i32.add', 'i32.sub', 'i32.mul', 'i32.div_s', 'i32.div_u', 'i32.rem_s', 'i32.rem_u', 'i32.and', 'i32.or', 'i32.xor', 'i32.shl', 'i32.shr_s', 'i32.shr_u', 'i32.rotl', 'i32.rotr',
   'i64.clz', 'i64.ctz', 'i64.popcnt', 'i64.add', 'i64.sub', 'i64.mul', 'i64.div_s', 'i64.div_u', 'i64.rem_s', 'i64.rem_u', 'i64.and', 'i64.or', 'i64.xor', 'i64.shl', 'i64.shr_s', 'i64.shr_u', 'i64.rotl', 'i64.rotr',
   'f32.abs', 'f32.neg', 'f32.ceil', 'f32.floor', 'f32.trunc', 'f32.nearest', 'f32.sqrt', 'f32.add', 'f32.sub', 'f32.mul', 'f32.div', 'f32.min', 'f32.max', 'f32.copysign',
@@ -27,15 +27,16 @@ export const OP = [
   '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',
 ],
-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 },
-KIND = { func: 0, table: 1, memory: 2, global: 3 },
-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,
-}
-
-OP.map((op,i)=>OP[op]=i) // init op names
+  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 },
+  KIND = { func: 0, table: 1, memory: 2, global: 3 },
+  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,
+  },
+  BLOCK = {
+    loop: 1, block: 1, if: 1, end: -1, return: -1
+  }