watr 4.3.1 → 4.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watr",
-  "version": "4.3.1",
+  "version": "4.3.4",
   "description": "Light & fast WAT compiler – WebAssembly Text to binary, parse, print, transform",
   "main": "watr.js",
   "bin": {
@@ -46,7 +46,7 @@
     "test": "node test",
     "test:repl": "npx playwright test",
     "types": "npx tsc src/*.js watr.js --allowJs --declaration --emitDeclarationOnly --declarationMap --outDir types",
-    "prepublishOnly": "npm run build && npm run types",
+    "prepublishOnly": "npm test && npm run build && npm run types",
     "prepare": "git submodule update --init --recursive 2>/dev/null || true"
   },
   "repository": {

package/src/encode.js

@@ -106,8 +106,9 @@ i32.parse = n => {
  */
 export function i64(n, buffer = []) {
   if (typeof n === 'string') n = i64.parse(n)
+  else if (typeof n === 'number') n = BigInt(n)
   // Normalize unsigned to signed: values > MAX_INT64 become negative
-  else if (typeof n === 'bigint' && n > 0x7fffffffffffffffn) {
+  if (typeof n === 'bigint' && n > 0x7fffffffffffffffn) {
     n = n - 0x10000000000000000n
   }
 
@@ -122,35 +123,31 @@ export function i64(n, buffer = []) {
   }
   return buffer
 }
+const _buf = new ArrayBuffer(8)
+const _u8 = new Uint8Array(_buf), _i32 = new Int32Array(_buf), _f32 = new Float32Array(_buf), _f64 = new Float64Array(_buf), _i64 = new BigInt64Array(_buf)
+
 i64.parse = n => {
   n = cleanInt(n)
   n = n[0] === '-' ? -BigInt(n.slice(1)) : BigInt(n) // can be -0x123
   if (n < -0x8000000000000000n || n > 0xffffffffffffffffn) err(`i64 constant out of range`)
-  byteView.setBigInt64(0, n)
-  return byteView.getBigInt64(0)
+  _i64[0] = n
+  return _i64[0]
 }
 
-const byteView = new DataView(new Float64Array(1).buffer)
-
 const F32_SIGN = 0x80000000, F32_NAN = 0x7f800000
 export function f32(input, value, idx) {
   if (typeof input === 'string' && ~(idx = input.indexOf('nan:'))) {
     value = i32.parse(input.slice(idx + 4))
     value |= F32_NAN
     if (input[0] === '-') value |= F32_SIGN
-    byteView.setInt32(0, value)
+    _i32[0] = value
   }
   else {
     value = typeof input === 'string' ? f32.parse(input) : input
-    byteView.setFloat32(0, value);
+    _f32[0] = value
   }
 
-  return [
-    byteView.getUint8(3),
-    byteView.getUint8(2),
-    byteView.getUint8(1),
-    byteView.getUint8(0)
-  ];
+  return [_u8[0], _u8[1], _u8[2], _u8[3]]
 }
 
 const F64_SIGN = 0x8000000000000000n, F64_NAN = 0x7ff0000000000000n
@@ -159,23 +156,14 @@ export function f64(input, value, idx) {
     value = i64.parse(input.slice(idx + 4))
     value |= F64_NAN
     if (input[0] === '-') value |= F64_SIGN
-    byteView.setBigInt64(0, value)
+    _i64[0] = value
   }
   else {
     value = typeof input === 'string' ? f64.parse(input) : input
-    byteView.setFloat64(0, value);
+    _f64[0] = value
   }
 
-  return ([
-    byteView.getUint8(7),
-    byteView.getUint8(6),
-    byteView.getUint8(5),
-    byteView.getUint8(4),
-    byteView.getUint8(3),
-    byteView.getUint8(2),
-    byteView.getUint8(1),
-    byteView.getUint8(0)
-  ]);
+  return [_u8[0], _u8[1], _u8[2], _u8[3], _u8[4], _u8[5], _u8[6], _u8[7]]
 }
 
 f64.parse = (input, max=Number.MAX_VALUE) => {
@@ -219,3 +207,10 @@ f64.parse = (input, max=Number.MAX_VALUE) => {
 }
 
 f32.parse = input => f64.parse(input, 3.4028234663852886e+38)
+
+export const v128 = (input) => {
+  let n = typeof input === 'string' ? BigInt(input.replaceAll('_', '')) : BigInt(input)
+  let arr = new Uint8Array(16)
+  for (let i = 0; i < 16; i++) arr[i] = Number(n & 0xffn), n >>= 8n
+  return [...arr]
+}

package/src/optimize.js

@@ -285,6 +285,9 @@ const treeshake = (ast) => {
 
 // ==================== CONSTANT FOLDING ====================
 
+/** IEEE 754 roundTiesToEven (bankers' rounding) */
+const roundEven = (x) => x - Math.floor(x) !== 0.5 ? Math.round(x) : 2 * Math.round(x / 2)
+
 /** Operators that can be constant-folded */
 const FOLDABLE = {
   // i32
@@ -358,7 +361,7 @@ const FOLDABLE = {
   'f32.ceil': (a) => Math.fround(Math.ceil(a)),
   'f32.floor': (a) => Math.fround(Math.floor(a)),
   'f32.trunc': (a) => Math.fround(Math.trunc(a)),
-  'f32.nearest': (a) => Math.fround(Math.round(a)),
+  'f32.nearest': (a) => Math.fround(roundEven(a)),
 
   'f64.add': (a, b) => a + b,
   'f64.sub': (a, b) => a - b,
@@ -370,7 +373,7 @@ const FOLDABLE = {
   'f64.ceil': (a) => Math.ceil(a),
   'f64.floor': (a) => Math.floor(a),
   'f64.trunc': (a) => Math.trunc(a),
-  'f64.nearest': (a) => Math.round(a),
+  'f64.nearest': roundEven,
 }
 
 /**
@@ -804,7 +807,7 @@ const localReuse = (ast) => {
       if (!Array.isArray(sub)) continue
 
       if (sub[0] === 'local') {
-        localDecls.push({ idx: i, node: sub })
+        localDecls.push({ node: sub, idx: i })
         // (local $name type) or (local type)
         if (typeof sub[1] === 'string' && sub[1][0] === '$') {
           localTypes.set(sub[1], sub[2])
@@ -842,82 +845,127 @@ const localReuse = (ast) => {
   return result
 }
 
-// ==================== CONSTANT PROPAGATION ====================
+// ==================== PROPAGATION & LOCAL ELIMINATION ====================
+
+/** Check if expression is pure (no side effects, no memory ops) */
+const isPure = (node) => {
+  if (!Array.isArray(node)) return true
+  const op = node[0]
+  if (typeof op !== 'string') return false
+  if (op === 'call' || op === 'call_indirect' || op === 'return_call' || op === 'return_call_indirect') return false
+  if (op.includes('.store') || op.includes('.load') || op.includes('memory.')) return false
+  if (op === 'global.set') return false
+  for (let i = 1; i < node.length; i++) if (Array.isArray(node[i]) && !isPure(node[i])) return false
+  return true
+}
+
+/** Count all local.get/set/tee occurrences in one walk */
+const countLocalUses = (node) => {
+  const counts = new Map()
+  const ensure = name => { if (!counts.has(name)) counts.set(name, { gets: 0, sets: 0, tees: 0 }); return counts.get(name) }
+  walk(node, n => {
+    if (!Array.isArray(n) || n.length < 2 || typeof n[1] !== 'string') return
+    if (n[0] === 'local.get') ensure(n[1]).gets++
+    else if (n[0] === 'local.set') ensure(n[1]).sets++
+    else if (n[0] === 'local.tee') ensure(n[1]).tees++
+  })
+  return counts
+}
+
+/** Can this tracked value be substituted for a local.get? */
+const canSubst = (k) => getConst(k.val) || (k.pure && k.singleUse)
+
+/** Try substitute local.get nodes with known values */
+const substGets = (node, known) => walkPost(node, n => {
+  if (!Array.isArray(n) || n[0] !== 'local.get' || n.length !== 2) return
+  const k = typeof n[1] === 'string' && known.get(n[1])
+  if (k && canSubst(k)) return clone(k.val)
+})
 
 /**
- * Propagate constant values through local variables.
- * When a local is set to a constant and not modified before use, replace the get with the constant.
- * @param {Array} ast
- * @returns {Array}
+ * Propagate values through locals and eliminate single-use/dead locals.
+ * Constants propagate to all uses; pure single-use exprs inline into get site.
+ * Multi-pass with batch counting for convergence.
  */
 const propagate = (ast) => {
   const result = clone(ast)
 
-  walk(result, (node) => {
-    if (!Array.isArray(node) || node[0] !== 'func') return
+  walk(result, (funcNode) => {
+    if (!Array.isArray(funcNode) || funcNode[0] !== 'func') return
 
-    // Track which locals have known constant values
-    // This is a simple single-pass analysis within straight-line code
-    const constLocals = new Map() // $name → const node
+    const params = new Set()
+    for (const sub of funcNode)
+      if (Array.isArray(sub) && sub[0] === 'param' && typeof sub[1] === 'string') params.add(sub[1])
 
-    // Process function body in order
-    const processBlock = (block, startIdx = 1) => {
-      for (let i = startIdx; i < block.length; i++) {
-        const instr = block[i]
-        if (!Array.isArray(instr)) continue
+    for (let pass = 0; pass < 4; pass++) {
+      let changed = false
+      const uses = countLocalUses(funcNode)
+      const getUses = name => uses.get(name) || { gets: 0, sets: 0, tees: 0 }
+      const known = new Map()
 
+      for (let i = 1; i < funcNode.length; i++) {
+        const instr = funcNode[i]
+        if (!Array.isArray(instr)) continue
         const op = instr[0]
 
-        // local.set $x (const) → remember constant
-        if (op === 'local.set' && instr.length === 3) {
-          const local = instr[1]
-          const val = instr[2]
-          const c = getConst(val)
-          if (c && typeof local === 'string') {
-            constLocals.set(local, val)
-          } else if (typeof local === 'string') {
-            constLocals.delete(local) // invalidate if set to non-const
-          }
-        }
-        // local.tee also sets
-        else if (op === 'local.tee' && instr.length === 3) {
-          const local = instr[1]
-          const val = instr[2]
-          const c = getConst(val)
-          if (c && typeof local === 'string') {
-            constLocals.set(local, val)
-          } else if (typeof local === 'string') {
-            constLocals.delete(local)
-          }
+        if (op === 'param' || op === 'result' || op === 'local' || op === 'type' || op === 'export') continue
+
+        // Track local.set values
+        if (op === 'local.set' && instr.length === 3 && typeof instr[1] === 'string') {
+          substGets(instr[2], known) // substitute known values in RHS
+          const u = getUses(instr[1])
+          known.set(instr[1], {
+            val: instr[2], pure: isPure(instr[2]),
+            singleUse: u.gets <= 1 && u.sets <= 1 && u.tees === 0
+          })
+          continue
         }
-        // local.get $x → replace with const if known
-        else if (op === 'local.get' && instr.length === 2) {
-          const local = instr[1]
-          if (typeof local === 'string' && constLocals.has(local)) {
-            const constVal = constLocals.get(local)
-            // Replace in place
-            instr.length = 0
-            instr.push(...clone(constVal))
+
+        // Invalidate at control-flow boundaries
+        if (op === 'block' || op === 'loop' || op === 'if') known.clear()
+        // Calls only invalidate non-constant tracked values
+        if (op === 'call' || op === 'call_indirect' || op === 'return_call' || op === 'return_call_indirect')
+          for (const [k, v] of known) if (!getConst(v.val)) known.delete(k)
+
+        // Substitute: standalone local.get (walkPost can't replace root)
+        if (op === 'local.get' && instr.length === 2 && typeof instr[1] === 'string') {
+          const k = known.get(instr[1])
+          if (k && canSubst(k)) {
+            const r = clone(k.val)
+            instr.length = 0; instr.push(...(Array.isArray(r) ? r : [r]))
+            changed = true; continue
           }
         }
-        // Control flow invalidates all knowledge (conservative)
-        else if (op === 'block' || op === 'loop' || op === 'if' || op === 'call' || op === 'call_indirect') {
-          constLocals.clear()
+
+        // Substitute nested local.gets (skip control-flow nodes — locals may be reassigned inside)
+        if (op !== 'block' && op !== 'loop' && op !== 'if') {
+          const prev = JSON.stringify(instr)
+          substGets(instr, known)
+          if (JSON.stringify(instr) !== prev) changed = true
         }
+      }
 
-        // Recursively process nested expressions that might have local.get
-        walkPost(instr, (n) => {
-          if (!Array.isArray(n) || n[0] !== 'local.get' || n.length !== 2) return
-          const local = n[1]
-          if (typeof local === 'string' && constLocals.has(local)) {
-            const constVal = constLocals.get(local)
-            return clone(constVal)
-          }
-        })
+      // Remove dead stores + unused local decls in one reverse pass
+      const postUses = countLocalUses(funcNode)
+      const pu = name => postUses.get(name) || { gets: 0, sets: 0, tees: 0 }
+      for (let i = funcNode.length - 1; i >= 1; i--) {
+        const sub = funcNode[i]
+        if (!Array.isArray(sub)) continue
+        const name = typeof sub[1] === 'string' ? sub[1] : null
+        if (!name || params.has(name)) continue
+        const u = pu(name)
+        // Dead store: set but never read, pure RHS
+        if (sub[0] === 'local.set' && u.gets === 0 && u.tees === 0 && isPure(sub[2])) {
+          funcNode.splice(i, 1); changed = true
+        }
+        // Unused local declaration
+        else if (sub[0] === 'local' && name[0] === '$' && u.gets === 0 && u.sets === 0 && u.tees === 0) {
+          funcNode.splice(i, 1); changed = true
+        }
       }
-    }
 
-    processBlock(node)
+      if (!changed) break
+    }
   })
 
   return result

package/types/src/encode.d.ts

@@ -55,4 +55,5 @@ export namespace i8 { }
  */
 export function i16(n: number | string, buffer?: number[]): number[];
 export namespace i16 { }
+export function v128(input: any): any[];
 //# sourceMappingURL=encode.d.ts.map

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

@@ -1 +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,CAmBpB;;IACD,4BAMC;;AAKD,gEAkBC;;IAmED,mCAA6D;;AAhE7D,gEAsBC;;IAED,iDAsCC;;AA3MM,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"}
+{"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,CAoBpB;;IAID,4BAMC;;AAGD,gEAaC;;IA0DD,mCAA6D;;AAvD7D,gEAaC;;IAED,iDAsCC;;AA/LM,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;;AA6HM,wCAKN"}

package/types/src/optimize.d.ts

@@ -56,12 +56,11 @@ export function strength(ast: any[]): any[];
  */
 export function branch(ast: any[]): any[];
 /**
- * Propagate constant values through local variables.
- * When a local is set to a constant and not modified before use, replace the get with the constant.
- * @param {Array} ast
- * @returns {Array}
+ * Propagate values through locals and eliminate single-use/dead locals.
+ * Constants propagate to all uses; pure single-use exprs inline into get site.
+ * Multi-pass with batch counting for convergence.
  */
-export function propagate(ast: any[]): any[];
+export function propagate(ast: any): any;
 /**
  * Inline tiny functions (single expression, no locals, no params or simple params).
  * @param {Array} ast

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

@@ -1 +1 @@
-{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAioCA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAwB/B;AAtkCD;;;;;GAKG;AACH,6CA8LC;AAyHD;;;;GAIG;AACH,wCAmCC;AAwQD;;;;GAIG;AACH,4CAuBC;AA+CD;;;;;GAKG;AACH,8CAqDC;AApTD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CA0EC;AAiJD;;;;;GAKG;AACH,6CAuEC;AAID;;;;GAIG;AACH,0CAwFC;AAn+BD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAe/B"}
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAirCA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAwB/B;AAtnCD;;;;;GAKG;AACH,6CA8LC;AA4HD;;;;GAIG;AACH,wCAmCC;AAwQD;;;;GAIG;AACH,4CAuBC;AA+CD;;;;;GAKG;AACH,8CAqDC;AApTD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CA0EC;AAoLD;;;;GAIG;AACH,yCAkFC;AAID;;;;GAIG;AACH,0CAwFC;AAnhCD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAe/B"}

package/watr.js

@@ -152,7 +152,7 @@ function genImports(imports) {
 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] instanceof Uint8Array)) {
+  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()
   }
 
@@ -189,7 +189,7 @@ function compile(source, ...values) {
           return parsed
         }
         // Uint8Array → convert to plain array for flat() compatibility
-        if (value instanceof Uint8Array) return [...value]
+        if (value.byteLength !== undefined) return [...value]
         return value
       }
       return node