watr 3.3.0 → 4.0.0

package/src/util.js

@@ -1,49 +1,81 @@
-import { ESCAPE } from './const.js'
-
-export const err = text => { throw Error(text) }
+/**
+ * Throws an error with optional source position.
+ * Uses err.src for source and err.i for default position.
+ * If pos provided or err.i set, appends "at line:col".
+ *
+ * @param {string} text - Error message
+ * @param {number} [pos] - Byte offset in source (defaults to err.i)
+ * @throws {Error}
+ */
+export const err = (text, pos=err.i) => {
+  if (pos != null && err.src) {
+    let line = 1, col = 1
+    for (let i = 0; i < pos && i < err.src.length; i++) {
+      if (err.src[i] === '\n') line++, col = 1
+      else col++
+    }
+    text += ` at ${line}:${col}`
+  }
+  throw Error(text)
+}
 
+/**
+ * Deep clone an array tree structure.
+ * @param {Array} items - Array to clone
+ * @returns {Array} Cloned array
+ */
 export const clone = items => items.map(item => Array.isArray(item) ? clone(item) : item)
 
+/** Regex to detect invalid underscore placement in numbers */
 export const sepRE = /^_|_$|[^\da-f]_|_[^\da-f]/i
 
+/** Regex to match valid integer literals (decimal or hex) */
 export const intRE = /^[+-]?(?:0x[\da-f]+|\d+)$/i
 
-// build string binary - convert WAT string to byte array
-const enc = new TextEncoder()
-export const str = (...parts) => {
-  let s = parts.map(s => s[0] === '"' ? s.slice(1, -1) : s).join(''), res = []
-
-  for (let i = 0; i < s.length; i++) {
-    let c = s.charCodeAt(i)
-    if (c === 92) { // backslash
-      let n = s[i + 1]
-      // \u{...} unicode - decode and UTF-8 encode
-      if (n === 'u' && s[i + 2] === '{') {
-        let hex = s.slice(i + 3, i = s.indexOf('}', i + 3))
-        res.push(...enc.encode(String.fromCodePoint(parseInt(hex, 16))))
-        // i now points to '}', loop i++ will move past it
-      }
-      // Named escape
-      else if (ESCAPE[n]) {
-        res.push(ESCAPE[n])
-        i++ // skip the named char, loop i++ will move past backslash
-      }
-      // \xx hex byte (raw byte, not UTF-8 decoded)
-      else {
-        res.push(parseInt(s.slice(i + 1, i + 3), 16))
-        i += 2 // skip two hex digits, loop i++ will complete the skip
+const tenc = new TextEncoder();
+const tdec = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const escape = { n: 10, r: 13, t: 9, '"': 34, "'": 39, '\\': 92 }
+
+
+/**
+ * Convert WAT string literal (with quotes) to byte array.
+ * Handles escape sequences: \n, \t, \r, \xx (hex), \u{xxxx} (unicode).
+ * Attaches valueOf() returning original string for roundtrip.
+ *
+ * @param {string} s - String literal including quotes, e.g. '"hello\n"'
+ * @returns {number[]} Byte array with valueOf() method
+ */
+export const str = s => {
+  let bytes = [], i = 1, code, c, buf = '' // i=1 to skip opening quote
+
+  const commit = () => (buf && bytes.push(...tenc.encode(buf)), buf = '')
+
+  while (i < s.length - 1) { // -1 to skip closing quote
+    c = s[i++], code = null
+
+    if (c === '\\') {
+      // \u{abcd}
+      if (s[i] === 'u') {
+        i++, i++ // 'u{'
+        c = String.fromCodePoint(parseInt(s.slice(i, i = s.indexOf('}', i)), 16))
+        i++ // '}'
       }
+      // \n, \t, \r
+      else if (escape[s[i]]) code = escape[s[i++]]
+      // \00 - raw bytes
+      else if (!isNaN(code = parseInt(s[i] + s[i + 1], 16))) i++, i++
+      // \*
+      else c += s[i]
     }
-    // Multi-byte char - UTF-8 encode
-    else if (c > 255) {
-      res.push(...enc.encode(s[i]))
-    }
-    // Raw byte
-    else res.push(c)
+    code != null ? (commit(), bytes.push(code)) : buf += c
   }
-  return res
+  commit()
+
+  bytes.valueOf = () => s
+  return bytes
 }
 
+
 /**
  * Unescapes a WAT string literal by parsing escapes to bytes, then UTF-8 decoding.
  * Reuses str() for escape parsing to eliminate duplication.
@@ -51,4 +83,4 @@ export const str = (...parts) => {
  * @param {string} s - String with quotes and escapes, e.g. '"hello\\nworld"'
  * @returns {string} Unescaped string without quotes, e.g. 'hello\nworld'
  */
-export const unescape = s => new TextDecoder().decode(new Uint8Array(str(s)))
+export const unescape = s => tdec.decode(new Uint8Array(str(s)))

package/types/src/compile.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export default function compile(nodes: string | any[]): Uint8Array;
+//# sourceMappingURL=compile.d.ts.map

package/types/src/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,uCAHW,MAAM,QAAM,GACV,UAAU,CAmLtB"}

package/types/src/const.d.ts

@@ -0,0 +1,87 @@
+export const INSTR: (string | string[])[];
+export namespace SECTION {
+    export let custom: number;
+    export let type: number;
+    let _import: number;
+    export { _import as import };
+    export let func: number;
+    export let table: number;
+    export let memory: number;
+    export let tag: number;
+    export let global: number;
+    let _export: number;
+    export { _export as export };
+    export let start: number;
+    export let elem: number;
+    export let datacount: number;
+    export let code: number;
+    export let data: number;
+}
+export namespace TYPE {
+    export let i8: number;
+    export let i16: number;
+    export let i32: number;
+    export let i64: number;
+    export let f32: number;
+    export let f64: number;
+    let _void: number;
+    export { _void as void };
+    export let v128: number;
+    export let exn: number;
+    export let noexn: number;
+    export let nofunc: number;
+    export let noextern: number;
+    export let none: number;
+    let func_1: number;
+    export { func_1 as func };
+    export let extern: number;
+    export let any: number;
+    export let eq: number;
+    export let i31: number;
+    export let struct: number;
+    export let array: number;
+    export let nullfuncref: number;
+    export let nullexternref: number;
+    export let nullexnref: number;
+    export let nullref: number;
+    export let funcref: number;
+    export let externref: number;
+    export let exnref: number;
+    export let anyref: number;
+    export let eqref: number;
+    export let i31ref: number;
+    export let structref: number;
+    export let arrayref: number;
+    export let ref: number;
+    export let refnull: number;
+    export let sub: number;
+    export let subfinal: number;
+    export let rec: number;
+}
+export namespace DEFTYPE {
+    let func_2: number;
+    export { func_2 as func };
+    let struct_1: number;
+    export { struct_1 as struct };
+    let array_1: number;
+    export { array_1 as array };
+    let sub_1: number;
+    export { sub_1 as sub };
+    let subfinal_1: number;
+    export { subfinal_1 as subfinal };
+    let rec_1: number;
+    export { rec_1 as rec };
+}
+export namespace KIND {
+    let func_3: number;
+    export { func_3 as func };
+    let table_1: number;
+    export { table_1 as table };
+    let memory_1: number;
+    export { memory_1 as memory };
+    let global_1: number;
+    export { global_1 as global };
+    let tag_1: number;
+    export { tag_1 as tag };
+}
+//# sourceMappingURL=const.d.ts.map

package/types/src/const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../src/const.js"],"names":[],"mappings":"AAIA,0CAqIC"}

package/types/src/encode.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Encode as fixed-width 5-byte ULEB128 (canonical form).
+ * Used by some tools for predictable binary layout.
+ *
+ * @param {number} value - 32-bit unsigned value
+ * @returns {number[]} 5-byte array
+ */
+export function uleb5(value: number): number[];
+/**
+ * Encode signed LEB128 for i32 values.
+ *
+ * @param {number|string} n - Signed 32-bit value
+ * @param {number[]} [buffer=[]] - Output buffer
+ * @returns {number[]} Encoded bytes
+ */
+export function i32(n: number | string, buffer?: number[]): number[];
+export namespace i32 {
+    function parse(n: any): any;
+}
+/**
+ * Encode signed LEB128 for i64 values (BigInt).
+ *
+ * @param {bigint|string} n - Signed 64-bit value
+ * @param {number[]} [buffer=[]] - Output buffer
+ * @returns {number[]} Encoded bytes
+ */
+export function i64(n: bigint | string, buffer?: number[]): number[];
+export namespace i64 {
+    function parse(n: any): any;
+}
+export function f32(input: any, value: any, idx: any): number[];
+export namespace f32 {
+    function parse(input: any): number;
+}
+export function f64(input: any, value: any, idx: any): number[];
+export namespace f64 {
+    function parse(input: any, max?: number): number;
+}
+export function uleb(n: number | bigint | string | null, buffer?: number[]): number[];
+/**
+ * Encode signed LEB128 for i32 values.
+ *
+ * @param {number|string} n - Signed 32-bit value
+ * @param {number[]} [buffer=[]] - Output buffer
+ * @returns {number[]} Encoded bytes
+ */
+export function i8(n: number | string, buffer?: number[]): number[];
+export namespace i8 { }
+/**
+ * Encode signed LEB128 for i32 values.
+ *
+ * @param {number|string} n - Signed 32-bit value
+ * @param {number[]} [buffer=[]] - Output buffer
+ * @returns {number[]} Encoded bytes
+ */
+export function i16(n: number | string, buffer?: number[]): number[];
+export namespace i16 { }
+//# sourceMappingURL=encode.d.ts.map

package/types/src/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/encode.js"],"names":[],"mappings":"AA6CA;;;;;;GAMG;AACH,6BAHW,MAAM,GACJ,MAAM,EAAE,CAapB;AAED;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAepB;;IAQD,4BAIC;;AAED;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAepB;;IACD,4BAMC;;AAKD,gEAkBC;;IAmED,mCAA6D;;AAhE7D,gEAsBC;;IAED,iDAsCC;;AAvMM,wBAJI,MAAM,GAAC,MAAM,GAAC,MAAM,GAAC,IAAI,WACzB,MAAM,EAAE,GACN,MAAM,EAAE,CA8BpB;AAsBD;;;;;;GAMG;AACH,sBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAepB;;AApBD;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAepB"}

package/types/src/parse.d.ts

@@ -0,0 +1,3 @@
+declare function _default(str: string): any[];
+export default _default;
+//# sourceMappingURL=parse.d.ts.map

package/types/src/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/parse.js"],"names":[],"mappings":"AASe,+BAHJ,MAAM,SAqDhB"}

package/types/src/print.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Formats a tree or a WAT (WebAssembly Text) string into a readable format.
+ *
+ * @param {string | Array} tree - The code to print. If a string is provided, it will be parsed into a tree structure first.
+ * @param {Object} [options={}] - Optional settings for printing.
+ * @param {string} [options.indent='  '] - The string used for one level of indentation. Defaults to two spaces.
+ * @param {string} [options.newline='\n'] - The string used for line breaks. Defaults to a newline character.
+ * @param {boolean} [options.comments=false] - Whether to include comments in the output. Defaults to false.
+ * @returns {string} The formatted WAT string.
+ */
+export default function print(tree: string | any[], options?: {
+    indent?: string;
+    newline?: string;
+    comments?: boolean;
+}): string;
+//# sourceMappingURL=print.d.ts.map

package/types/src/print.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../../src/print.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,oCAPW,MAAM,QAAQ,YAEtB;IAAyB,MAAM,GAAvB,MAAM;IACW,OAAO,GAAxB,MAAM;IACY,QAAQ,GAA1B,OAAO;CACf,GAAU,MAAM,CA0GlB"}

package/types/src/util.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Throws an error with optional source position.
+ * Uses err.src for source and err.i for default position.
+ * If pos provided or err.i set, appends "at line:col".
+ *
+ * @param {string} text - Error message
+ * @param {number} [pos] - Byte offset in source (defaults to err.i)
+ * @throws {Error}
+ */
+export const err: (text: string, pos?: number) => never;
+export function clone(items: any[]): any[];
+/** Regex to detect invalid underscore placement in numbers */
+export const sepRE: RegExp;
+/** Regex to match valid integer literals (decimal or hex) */
+export const intRE: RegExp;
+export function str(s: string): number[];
+export function unescape(s: string): string;
+//# sourceMappingURL=util.d.ts.map

package/types/src/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,mBAAoB,MAJT,MAIa,EAAE,MAHf,MAGwB,WAUlC;AAOM,2CAAkF;AAEzF,8DAA8D;AAC9D,2BAAiD;AAEjD,6DAA6D;AAC7D,2BAAiD;AAe1C,uBAHI,MAAM,GACJ,MAAM,EAAE,CA8BpB;AAUM,4BAHI,MAAM,GACJ,MAAM,CAE6C"}

package/types/watr.d.ts

@@ -0,0 +1,34 @@
+export default watr;
+/**
+ * Compile and instantiate WAT, returning exports.
+ *
+ * @param {string|TemplateStringsArray} strings - WAT source string or template strings
+ * @param {...any} values - Interpolation values (for template literal)
+ * @returns {WebAssembly.Exports} Module exports
+ *
+ * @example
+ * // Template literal
+ * const { add } = watr`(func (export "add") (param i32 i32) (result i32)
+ *   (i32.add (local.get 0) (local.get 1))
+ * )`
+ *
+ * // Plain string
+ * const { add } = watr('(func (export "add") (param i32 i32) (result i32) (i32.add (local.get 0) (local.get 1)))')
+ */
+export function watr(strings: string | TemplateStringsArray, ...values: any[]): WebAssembly.Exports;
+/**
+ * Compile WAT to binary. Supports both string and template literal.
+ *
+ * @param {string|TemplateStringsArray} source - WAT source or template strings
+ * @param {...any} values - Interpolation values (for template literal)
+ * @returns {Uint8Array} WebAssembly binary
+ *
+ * @example
+ * compile('(func (export "f") (result i32) (i32.const 42))')
+ * compile`(func (export "f") (result f64) (f64.const ${Math.PI}))`
+ */
+export function compile(source: string | TemplateStringsArray, ...values: any[]): Uint8Array;
+import parse from './src/parse.js';
+import print from './src/print.js';
+export { parse, print };
+//# sourceMappingURL=watr.d.ts.map

package/types/watr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watr.d.ts","sourceRoot":"","sources":["../watr.js"],"names":[],"mappings":";AAyNA;;;;;;;;;;;;;;;GAeG;AACH,8BAbW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,WAAW,CAAC,OAAO,CAgB/B;AAxGD;;;;;;;;;;GAUG;AACH,gCARW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,UAAU,CA4EtB;kBAhNiB,gBAAgB;kBAChB,gBAAgB"}

package/watr.js

@@ -4,9 +4,239 @@
  * @module watr
  */
 
-import compile from './src/compile.js'
+import _compile from './src/compile.js'
 import parse from './src/parse.js'
 import print from './src/print.js'
 
-export default compile
-export { compile, parse, print }
+/** Private Use Area character as placeholder for interpolation */
+const PUA = '\uE000'
+
+/**
+ * Infer result type from instruction name.
+ * E.g., 'i32.add' → 'i32', 'f64.const' → 'f64'
+ *
+ * @param {string} op - Instruction name
+ * @returns {string|null} Type string or null if unknown
+ */
+const instrType = op => {
+  if (!op || typeof op !== 'string') return null
+  // i32.add → i32, f64.const → f64, v128.load → v128
+  const prefix = op.split('.')[0]
+  if (/^[if](32|64)|v128/.test(prefix)) return prefix
+  // comparisons return i32: .eq .ne .lt .gt .le .ge .eqz
+  if (/\.(eq|ne|[lg][te]|eqz)/.test(op)) return 'i32'
+  // memory.size/grow return i32
+  if (op === 'memory.size' || op === 'memory.grow') return 'i32'
+  return null
+}
+
+/**
+ * Infer type of an expression AST node.
+ * Used for auto-import parameter type inference.
+ *
+ * @param {any} node - AST node (array or primitive)
+ * @param {Object} [ctx={}] - Context with locals/funcs type info
+ * @returns {string|null} Type string or null if unknown
+ */
+const exprType = (node, ctx = {}) => {
+  if (!Array.isArray(node)) {
+    // local.get $x - lookup type
+    if (typeof node === 'string' && node[0] === '$' && ctx.locals?.[node]) return ctx.locals[node]
+    return null
+  }
+  const [op, ...args] = node
+  // (i32.const 42) → i32
+  if (instrType(op)) return instrType(op)
+  // (local.get $x) → lookup
+  if (op === 'local.get' && ctx.locals?.[args[0]]) return ctx.locals[args[0]]
+  // (call $fn ...) → lookup function result type
+  if (op === 'call' && ctx.funcs?.[args[0]]) return ctx.funcs[args[0]].result?.[0]
+  return null
+}
+
+/**
+ * Walk AST and transform nodes depth-first.
+ * Handles array splicing when child has `_splice` property.
+ *
+ * @param {any} node - AST node to walk
+ * @param {Function} fn - Transform function (node) => node
+ * @returns {any} Transformed node
+ */
+function walk(node, fn) {
+  node = fn(node)
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      let child = walk(node[i], fn)
+      if (child?._splice) node.splice(i, 1, ...child), i += child.length - 1
+      else node[i] = child
+    }
+  }
+  return node
+}
+
+/**
+ * Find function references in AST and infer import signatures.
+ * Scans for `(call fn args...)` where fn is a JS function,
+ * infers param types from arguments, generates import entries.
+ *
+ * @param {Array} ast - AST to scan
+ * @param {Function[]} funcs - Functions to look for
+ * @returns {Array<{idx: number, name: string, params: string[], fn: Function}>} Import entries
+ */
+function inferImports(ast, funcs) {
+  const imports = []
+  const importMap = new Map() // fn → import index
+
+  walk(ast, node => {
+    if (!Array.isArray(node)) return node
+
+    // Find (call ${fn} args...) where fn is a function
+    if (node[0] === 'call' && typeof node[1] === 'function') {
+      const fn = node[1]
+
+      if (!importMap.has(fn)) {
+        // Infer param types from arguments
+        const params = []
+        for (let i = 2; i < node.length; i++) {
+          const t = exprType(node[i])
+          if (t) params.push(t)
+        }
+
+        // Create import entry
+        const idx = imports.length
+        const name = fn.name || `$fn${idx}`
+        importMap.set(fn, { idx, name: name.startsWith('$') ? name : '$' + name, params, fn })
+        imports.push(importMap.get(fn))
+      }
+
+      // Replace function with import reference
+      const imp = importMap.get(fn)
+      node[1] = imp.name
+    }
+
+    return node
+  })
+
+  return imports
+}
+
+/**
+ * Generate WAT import declarations from inferred imports.
+ *
+ * @param {Array<{name: string, params: string[]}>} imports - Import entries
+ * @returns {Array} AST nodes for import declarations
+ */
+function genImports(imports) {
+  return imports.map(({ name, params }) =>
+    ['import', '"env"', `"${name.slice(1)}"`, ['func', name, ...params.map(t => ['param', t])]]
+  )
+}
+
+/**
+ * Compile WAT to binary. Supports both string and template literal.
+ *
+ * @param {string|TemplateStringsArray} source - WAT source or template strings
+ * @param {...any} values - Interpolation values (for template literal)
+ * @returns {Uint8Array} WebAssembly binary
+ *
+ * @example
+ * compile('(func (export "f") (result i32) (i32.const 42))')
+ * compile`(func (export "f") (result f64) (f64.const ${Math.PI}))`
+ */
+function compile(source, ...values) {
+  // Template literal: source is TemplateStringsArray
+  if (Array.isArray(source) && source.raw) {
+    // Build source with placeholders
+    let src = source[0]
+    for (let i = 0; i < values.length; i++) {
+      src += PUA + source[i + 1]
+    }
+
+    // Parse to AST
+    let ast = parse(src)
+
+    // Collect functions for auto-import
+    const funcsToImport = []
+
+    // Replace placeholders with actual values
+    let idx = 0
+    ast = walk(ast, node => {
+      if (node === PUA) {
+        const value = values[idx++]
+        // Function → mark for import inference
+        if (typeof value === 'function') {
+          funcsToImport.push(value)
+          return value // keep function reference for now
+        }
+        // String containing WAT code → parse and splice
+        if (typeof value === 'string' && (value[0] === '(' || /^\s*\(/.test(value))) {
+          const parsed = parse(value)
+          if (Array.isArray(parsed) && Array.isArray(parsed[0])) {
+            parsed._splice = true
+          }
+          return parsed
+        }
+        // Uint8Array → convert to plain array for flat() compatibility
+        if (value instanceof Uint8Array) return [...value]
+        return value
+      }
+      return node
+    })
+
+    // If we have functions to import, infer and generate imports
+    let importObjs = null
+    if (funcsToImport.length) {
+      const imports = inferImports(ast, funcsToImport)
+      if (imports.length) {
+        // Insert import declarations at start of module
+        const importDecls = genImports(imports)
+        if (ast[0] === 'module') {
+          ast.splice(1, 0, ...importDecls)
+        } else if (typeof ast[0] === 'string') {
+          // Single top-level node like ['func', ...] - wrap in array with imports
+          ast = [...importDecls, ast]
+        } else {
+          // Multiple top-level nodes like [['func', ...], ['func', ...]]
+          ast.unshift(...importDecls)
+        }
+        // Build imports object for instantiation
+        importObjs = { env: {} }
+        for (const imp of imports) {
+          importObjs.env[imp.name.slice(1)] = imp.fn
+        }
+      }
+    }
+
+    const binary = _compile(ast)
+    // Attach imports for watr() to use
+    if (importObjs) binary._imports = importObjs
+    return binary
+  }
+  return _compile(source)
+}
+
+/**
+ * Compile and instantiate WAT, returning exports.
+ *
+ * @param {string|TemplateStringsArray} strings - WAT source string or template strings
+ * @param {...any} values - Interpolation values (for template literal)
+ * @returns {WebAssembly.Exports} Module exports
+ *
+ * @example
+ * // Template literal
+ * const { add } = watr`(func (export "add") (param i32 i32) (result i32)
+ *   (i32.add (local.get 0) (local.get 1))
+ * )`
+ *
+ * // Plain string
+ * const { add } = watr('(func (export "add") (param i32 i32) (result i32) (i32.add (local.get 0) (local.get 1)))')
+ */
+function watr(strings, ...values) {
+  const binary = compile(strings, ...values)
+  const module = new WebAssembly.Module(binary)
+  const instance = new WebAssembly.Instance(module, binary._imports)
+  return instance.exports
+}
+
+export default watr
+export { watr, compile, parse, print }