watr 4.6.6 → 4.6.7

package/types/src/polyfill.d.ts

@@ -15,27 +15,21 @@
  */
 export default function polyfill(ast: any[] | string, opts?: boolean | string | any): any[];
 /**
- * Detect which polyfillable features are used in AST.
+ * Detect which polyfillable features an AST uses.
+ *
  * @param {Array} ast
  * @returns {Set<string>} Set of feature names
  */
 export function detect(ast: any[]): Set<string>;
 /**
- * Normalize polyfill options to { feature: bool } map.
+ * Normalize polyfill options to a { feature: bool } map. `true` enables every
+ * feature, a string enables only the named ones (or all via `'all'`), and an
+ * explicit object is passed through untouched.
+ *
  * @param {boolean|string|Object} opts
  * @returns {Object} Normalized options
  */
 export function normalize(opts: boolean | string | any): any;
-export namespace FEATURES {
-    let funcref: string[];
-    let sign_ext: string[];
-    let nontrapping: string[];
-    let bulk_memory: string[];
-    let return_call: string[];
-    let i31ref: string[];
-    let extended_const: string[];
-    let multi_value: any[];
-    let gc: string[];
-    let ref_cast: string[];
-}
+/** Feature name → trigger-op list — the public catalogue of polyfillable features. */
+export const FEATURES: any;
 //# sourceMappingURL=polyfill.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"polyfill.d.ts","sourceRoot":"","sources":["../../src/polyfill.js"],"names":[],"mappings":"AA0pCA;;;;;;;;;;;;;;GAcG;AACH,sCAZW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SA0B/B;AArnCD;;;;GAIG;AACH,oCAFa,GAAG,CAAC,MAAM,CAAC,CAyCvB;AAnFD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAW/B"}
+{"version":3,"file":"polyfill.d.ts","sourceRoot":"","sources":["../../src/polyfill.js"],"names":[],"mappings":"AA+mCA;;;;;;;;;;;;;;GAcG;AACH,sCAZW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAyB/B;AA1ED;;;;;GAKG;AACH,oCAFa,GAAG,CAAC,MAAM,CAAC,CAuCvB;AA5DD;;;;;;;GAOG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAU/B;AAlBD,sFAAsF;AACtF,2BAAqE"}

package/types/src/template.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Compile WAT to binary. Supports string, AST, and tagged template.
+ *
+ * @param {Object} backend - { parse, compile, optimize, polyfill } primitives
+ * @param {string|Array|TemplateStringsArray} source - WAT source, AST, or template strings
+ * @param {any[]} values - Interpolation values (for template literal)
+ *   Last value can be options object:
+ *   - polyfill: true | 'funcref sign_ext' | { funcref: true }
+ *   - optimize: true | 'fold treeshake' | { fold: true }
+ * @returns {Uint8Array} WebAssembly binary
+ */
+export function compile(backend: any, source: string | any[] | TemplateStringsArray, values: any[]): Uint8Array;
+/**
+ * Compile and instantiate WAT, returning exports.
+ *
+ * @param {Object} backend - { parse, compile, optimize, polyfill } primitives
+ * @param {string|Array|TemplateStringsArray} source - WAT source, AST, or template strings
+ * @param {any[]} values - Interpolation values (for template literal)
+ * @returns {WebAssembly.Exports} Module exports
+ */
+export function watr(backend: any, source: string | any[] | TemplateStringsArray, values: any[]): WebAssembly.Exports;
+//# sourceMappingURL=template.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/template.js"],"names":[],"mappings":"AA4HA;;;;;;;;;;GAUG;AACH,8CAPW,MAAM,WAAO,oBAAoB,UACjC,GAAG,EAAE,GAIH,UAAU,CAgGtB;AAED;;;;;;;GAOG;AACH,2CAJW,MAAM,WAAO,oBAAoB,UACjC,GAAG,EAAE,GACH,WAAW,CAAC,OAAO,CAO/B"}

package/types/src/util.d.ts

@@ -8,11 +8,13 @@
  * @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;
+export function clone(node: any): any;
+export function walk(node: any, fn: Function, parent?: any, idx?: number): void;
+export function walkPost(node: any, fn: Function, parent?: any, idx?: number): any;
 //# sourceMappingURL=util.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,mBAAoB,MAJT,MAIa,EAAE,MAHf,MAG0B,WAUpC;AAOM,2CAAkF;AAEzF,8DAA8D;AAC9D,2BAAiD;AAEjD,6DAA6D;AAC7D,2BAAiD;AAe1C,uBAHI,MAAM,GACJ,MAAM,EAAE,CA8BpB;AAUM,4BAHI,MAAM,GACJ,MAAM,CAE6C"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,mBAAoB,MAJT,MAIa,EAAE,MAHf,MAG0B,WAUpC;AAED,8DAA8D;AAC9D,2BAAiD;AAEjD,6DAA6D;AAC7D,2BAAiD;AAe1C,uBAHI,MAAM,GACJ,MAAM,EAAE,CA8BpB;AAUM,4BAHI,MAAM,GACJ,MAAM,CAE6C;AAUzD,4BAHI,GAAG,GACD,GAAG,CAE2D;AASpE,2BALI,GAAG,yBAEH,GAAG,QACH,MAAM,QAKhB;AAgBM,+BANI,GAAG,yBAEH,GAAG,QACH,MAAM,GACJ,GAAG,CAOf"}

package/types/watr.d.ts

@@ -2,28 +2,22 @@ export default watr;
 /**
  * Compile and instantiate WAT, returning exports.
  *
- * @param {string|TemplateStringsArray} strings - WAT source string or template strings
+ * @param {string|TemplateStringsArray} source - WAT source 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;
+export function watr(source: 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)
- *   Last value can be options object:
- *   - polyfill: true | 'funcref sign_ext' | { funcref: true }
- *   - optimize: true | 'fold treeshake' | { fold: true }
+ * @param {...any} values - Interpolation values (for template literal).
+ *   Last value can be an options object: { polyfill, optimize }.
  * @returns {Uint8Array} WebAssembly binary
  *
  * @example

package/types/watr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watr.d.ts","sourceRoot":"","sources":["../watr.js"],"names":[],"mappings":";AAiPA;;;;;;;;;;;;;;;GAeG;AACH,8BAbW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,WAAW,CAAC,OAAO,CAgB/B;AA9HD;;;;;;;;;;;;;;GAcG;AACH,gCAZW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GAIJ,UAAU,CA+FtB;kBAxOiB,gBAAgB;kBAChB,gBAAgB;sBACZ,mBAAmB;sBACnB,mBAAmB"}
+{"version":3,"file":"watr.d.ts","sourceRoot":"","sources":["../watr.js"],"names":[],"mappings":";AAiCA;;;;;;;;;;;GAWG;AACH,6BATW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,WAAW,CAAC,OAAO,CAS/B;AA/BD;;;;;;;;;;;;GAYG;AACH,gCAVW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GAEJ,UAAU,CAStB;kBAxBiB,gBAAgB;kBAChB,gBAAgB;sBACZ,mBAAmB;sBACnB,mBAAmB"}

package/watr.js

@@ -9,139 +9,17 @@ import parse from './src/parse.js'
 import print from './src/print.js'
 import _polyfill from './src/polyfill.js'
 import _optimize from './src/optimize.js'
+import { compile as _tcompile, watr as _twatr } from './src/template.js'
 
-/** 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])]]
-  )
-}
+/** JS-source backend primitives for the tagged-template layer. */
+const backend = { parse, compile: _compile, optimize: _optimize, polyfill: _polyfill }
 
 /**
  * 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)
- *   Last value can be options object:
- *   - polyfill: true | 'funcref sign_ext' | { funcref: true }
- *   - optimize: true | 'fold treeshake' | { fold: true }
+ * @param {...any} values - Interpolation values (for template literal).
+ *   Last value can be an options object: { polyfill, optimize }.
  * @returns {Uint8Array} WebAssembly binary
  *
  * @example
@@ -150,116 +28,23 @@ function genImports(imports) {
  * compile(src, { polyfill: true, optimize: true })
  */
 function compile(source, ...values) {
-  // Options object as last argument (non-template call)
-  let opts = {}
-  if (!Array.isArray(source) && values.length && typeof values[values.length - 1] === 'object' && values[values.length - 1] !== null && !values[values.length - 1].byteLength) {
-    opts = values.pop()
-  }
-
-  // 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.byteLength !== undefined) 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
-        }
-      }
-    }
-
-    // Apply transforms
-    if (opts.polyfill) ast = _polyfill(ast, opts.polyfill)
-    if (opts.optimize) ast = _optimize(ast, opts.optimize)
-
-    const binary = _compile(ast)
-    // Attach imports for watr() to use
-    if (importObjs) binary._imports = importObjs
-    return binary
-  }
-
-  // String/AST source with options
-  if (opts.polyfill || opts.optimize) {
-    let ast = typeof source === 'string' ? parse(source) : source
-    if (opts.polyfill) ast = _polyfill(ast, opts.polyfill)
-    if (opts.optimize) ast = _optimize(ast, opts.optimize)
-    return _compile(ast)
-  }
-  return _compile(source)
+  return _tcompile(backend, source, values)
 }
 
 /**
  * Compile and instantiate WAT, returning exports.
  *
- * @param {string|TemplateStringsArray} strings - WAT source string or template strings
+ * @param {string|TemplateStringsArray} source - WAT source 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
+function watr(source, ...values) {
+  return _twatr(backend, source, values)
 }
 
 export default watr