watr 4.1.0 → 4.2.1

package/dist/watr.js

@@ -18,7 +18,7 @@ __export(encode_exports, {
 });
 
 // src/util.js
-var err = (text, pos = err.i) => {
+var err = (text, pos = err.loc) => {
   if (pos != null && err.src) {
     let line = 1, col = 1;
     for (let i = 0; i < pos && i < err.src.length; i++) {
@@ -951,7 +951,7 @@ var parse_default = (str2) => {
   let i = 0, level = [], buf = "", q = 0, depth = 0;
   const commit = () => buf && (level.push(buf), buf = "");
   const parseLevel = (pos) => {
-    level.i = pos;
+    level.loc = pos;
     for (let c, root, p; i < str2.length; ) {
       c = str2.charCodeAt(i);
       if (q === 34) buf += str2[i++], c === 92 ? buf += str2[i++] : c === 34 && (commit(), q = 0);
@@ -996,14 +996,14 @@ var cleanup = (node, result) => !Array.isArray(node) ? typeof node !== "string"
 ) : (
   // remove annotations like (@name ...) except @custom and @metadata.code.*
   node[0]?.[0] === "@" && node[0] !== "@custom" && !node[0]?.startsWith?.("@metadata.code.") ? null : (
-    // unwrap single-element array containing module (after removing comments), preserve .i
-    (result = node.map(cleanup).filter((n) => n != null), result.i = node.i, result.length === 1 && result[0]?.[0] === "module" ? result[0] : result)
+    // unwrap single-element array containing module (after removing comments), preserve .loc
+    (result = node.map(cleanup).filter((n) => n != null), result.loc = node.loc, result.length === 1 && result[0]?.[0] === "module" ? result[0] : result)
   )
 );
 function compile(nodes) {
   if (typeof nodes === "string") err.src = nodes, nodes = parse_default(nodes) || [];
   else err.src = "";
-  err.i = 0;
+  err.loc = 0;
   nodes = cleanup(nodes) || [];
   let idx = 0;
   if (nodes[0] === "module") idx++, isId(nodes[idx]) && idx++;
@@ -1015,12 +1015,25 @@ function compile(nodes) {
   ctx.metadata = {};
   nodes.slice(idx).filter((n) => {
     if (!Array.isArray(n)) {
-      let pos = err.src?.indexOf(n, err.i);
-      if (pos >= 0) err.i = pos;
+      let pos = err.loc, src = err.src, c;
+      while ((pos = src.indexOf(n, pos)) >= 0) {
+        c = src.charCodeAt(pos - 1);
+        if (pos > 0 && (c > 47 && c < 58 || c > 64 && c < 91 || c > 96 && c < 123 || c === 95 || c === 36)) {
+          pos++;
+          continue;
+        }
+        c = src.charCodeAt(pos + n.length);
+        if (c > 47 && c < 58 || c > 64 && c < 91 || c > 96 && c < 123 || c === 95) {
+          pos++;
+          continue;
+        }
+        break;
+      }
+      if (pos >= 0) err.loc = pos;
       err(`Unexpected token ${n}`);
     }
     let [kind, ...node] = n;
-    err.i = n.i;
+    err.loc = n.loc;
     if (kind === "@custom") {
       ctx.custom.push(node);
     } else if (kind === "rec") {
@@ -1037,7 +1050,7 @@ function compile(nodes) {
     else return true;
   }).forEach((n) => {
     let [kind, ...node] = n;
-    err.i = n.i;
+    err.loc = n.loc;
     let imported;
     if (kind === "import") [kind, ...node] = (imported = node).pop();
     let items = ctx[kind];
@@ -1147,7 +1160,7 @@ function normalize(nodes, ctx) {
       } else if ((node.startsWith("memory.") || node.endsWith("load") || node.endsWith("store")) && isIdx(nodes[0])) out.push(nodes.shift());
     } else if (Array.isArray(node)) {
       const op = node[0];
-      node.i != null && (err.i = node.i);
+      node.loc != null && (err.loc = node.loc);
       if (op?.startsWith?.("@metadata.code.")) {
         let type = op.slice(15);
         out.push(["@metadata", type, node[1]]);
@@ -1561,7 +1574,7 @@ var instr = (nodes, ctx) => {
       continue;
     }
     if (Array.isArray(op)) {
-      op.i != null && (err.i = op.i);
+      op.loc != null && (err.loc = op.loc);
       err(`Unknown instruction ${op[0]}`);
     }
     let [...bytes] = INSTR[op] || err(`Unknown instruction ${op}`);
@@ -2566,6 +2579,801 @@ function polyfill(ast, opts = true) {
   return ast;
 }
 
+// src/optimize.js
+var OPTS = {
+  treeshake: true,
+  // remove unused funcs/globals/types/tables
+  fold: true,
+  // constant folding
+  deadcode: true,
+  // eliminate dead code after unreachable/br/return
+  locals: true,
+  // remove unused locals
+  identity: true,
+  // remove identity ops (x + 0 → x)
+  strength: true,
+  // strength reduction (x * 2 → x << 1)
+  branch: true,
+  // simplify constant branches
+  propagate: true,
+  // constant propagation through locals
+  inline: true
+  // inline tiny functions
+};
+var ALL2 = Object.keys(OPTS);
+var normalize3 = (opts) => {
+  if (opts === true) return { ...OPTS };
+  if (opts === false) return {};
+  if (typeof opts === "string") {
+    const set = new Set(opts.split(/\s+/).filter(Boolean));
+    if (set.size === 1 && ALL2.includes([...set][0])) {
+      return Object.fromEntries(ALL2.map((f) => [f, set.has(f)]));
+    }
+    return Object.fromEntries(ALL2.map((f) => [f, set.has(f) || set.has("all")]));
+  }
+  return { ...OPTS, ...opts };
+};
+var clone2 = (node) => {
+  if (!Array.isArray(node)) return node;
+  return node.map(clone2);
+};
+var walk2 = (node, fn, parent, idx) => {
+  fn(node, parent, idx);
+  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) walk2(node[i], fn, node, i);
+};
+var walkPost2 = (node, fn, parent, idx) => {
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      const result2 = walkPost2(node[i], fn, node, i);
+      if (result2 !== void 0) node[i] = result2;
+    }
+  }
+  const result = fn(node, parent, idx);
+  return result !== void 0 ? result : node;
+};
+var treeshake = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  const funcs = /* @__PURE__ */ new Map();
+  const globals = /* @__PURE__ */ new Map();
+  const types = /* @__PURE__ */ new Map();
+  const tables = /* @__PURE__ */ new Map();
+  const memories = /* @__PURE__ */ new Map();
+  const exports = [];
+  const starts = [];
+  let funcIdx = 0, globalIdx = 0, typeIdx = 0, tableIdx = 0, memIdx = 0, importFuncIdx = 0;
+  for (const node of ast.slice(1)) {
+    if (!Array.isArray(node)) continue;
+    const kind = node[0];
+    if (kind === "type") {
+      const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : typeIdx;
+      types.set(name2, { node, idx: typeIdx, used: false });
+      if (typeof name2 === "string") types.set(typeIdx, types.get(name2));
+      typeIdx++;
+    } else if (kind === "func") {
+      const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : funcIdx;
+      const hasInlineExport = node.some((sub) => Array.isArray(sub) && sub[0] === "export");
+      funcs.set(name2, { node, idx: funcIdx, used: hasInlineExport });
+      if (typeof name2 === "string") funcs.set(funcIdx, funcs.get(name2));
+      funcIdx++;
+    } else if (kind === "global") {
+      const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : globalIdx;
+      const hasInlineExport = node.some((sub) => Array.isArray(sub) && sub[0] === "export");
+      globals.set(name2, { node, idx: globalIdx, used: hasInlineExport });
+      if (typeof name2 === "string") globals.set(globalIdx, globals.get(name2));
+      globalIdx++;
+    } else if (kind === "table") {
+      const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : tableIdx;
+      const hasInlineExport = node.some((sub) => Array.isArray(sub) && sub[0] === "export");
+      tables.set(name2, { node, idx: tableIdx, used: hasInlineExport });
+      if (typeof name2 === "string") tables.set(tableIdx, tables.get(name2));
+      tableIdx++;
+    } else if (kind === "memory") {
+      const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : memIdx;
+      const hasInlineExport = node.some((sub) => Array.isArray(sub) && sub[0] === "export");
+      memories.set(name2, { node, idx: memIdx, used: hasInlineExport });
+      if (typeof name2 === "string") memories.set(memIdx, memories.get(name2));
+      memIdx++;
+    } else if (kind === "import") {
+      for (const sub of node) {
+        if (Array.isArray(sub) && sub[0] === "func") {
+          const name2 = typeof sub[1] === "string" && sub[1][0] === "$" ? sub[1] : importFuncIdx;
+          funcs.set(name2, { node, idx: importFuncIdx, used: true, isImport: true });
+          if (typeof name2 === "string") funcs.set(importFuncIdx, funcs.get(name2));
+          importFuncIdx++;
+          funcIdx++;
+        }
+      }
+    } else if (kind === "export") {
+      exports.push(node);
+    } else if (kind === "start") {
+      starts.push(node);
+    }
+  }
+  for (const exp of exports) {
+    for (const sub of exp) {
+      if (!Array.isArray(sub)) continue;
+      const [kind, ref] = sub;
+      if (kind === "func" && funcs.has(ref)) funcs.get(ref).used = true;
+      else if (kind === "global" && globals.has(ref)) globals.get(ref).used = true;
+      else if (kind === "table" && tables.has(ref)) tables.get(ref).used = true;
+      else if (kind === "memory" && memories.has(ref)) memories.get(ref).used = true;
+    }
+  }
+  for (const start of starts) {
+    let ref = start[1];
+    if (typeof ref === "string" && ref[0] !== "$") ref = +ref;
+    if (funcs.has(ref)) funcs.get(ref).used = true;
+  }
+  let hasExports = exports.length > 0 || starts.length > 0;
+  if (!hasExports) {
+    for (const [, entry] of funcs) if (entry.used) {
+      hasExports = true;
+      break;
+    }
+    if (!hasExports) {
+      for (const [, entry] of globals) if (entry.used) {
+        hasExports = true;
+        break;
+      }
+    }
+    if (!hasExports) {
+      for (const [, entry] of tables) if (entry.used) {
+        hasExports = true;
+        break;
+      }
+    }
+    if (!hasExports) {
+      for (const [, entry] of memories) if (entry.used) {
+        hasExports = true;
+        break;
+      }
+    }
+  }
+  if (!hasExports) {
+    for (const [, entry] of funcs) entry.used = true;
+    for (const [, entry] of globals) entry.used = true;
+    for (const [, entry] of tables) entry.used = true;
+    for (const [, entry] of memories) entry.used = true;
+  }
+  for (const node of ast.slice(1)) {
+    if (!Array.isArray(node) || node[0] !== "elem") continue;
+    walk2(node, (n) => {
+      if (Array.isArray(n) && n[0] === "ref.func") {
+        const ref = n[1];
+        if (funcs.has(ref)) funcs.get(ref).used = true;
+      }
+      if (typeof n === "string" && n[0] === "$" && funcs.has(n)) funcs.get(n).used = true;
+    });
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [, entry] of funcs) {
+      if (!entry.used || entry.isImport) continue;
+      walk2(entry.node, (n) => {
+        if (!Array.isArray(n)) {
+          if (typeof n === "string" && n[0] === "$" && funcs.has(n) && !funcs.get(n).used) {
+            funcs.get(n).used = true;
+            changed = true;
+          }
+          return;
+        }
+        const [op, ref] = n;
+        if ((op === "call" || op === "return_call" || op === "ref.func") && funcs.has(ref) && !funcs.get(ref).used) {
+          funcs.get(ref).used = true;
+          changed = true;
+        }
+        if ((op === "global.get" || op === "global.set") && globals.has(ref) && !globals.get(ref).used) {
+          globals.get(ref).used = true;
+          changed = true;
+        }
+        if (op === "call_indirect" || op === "return_call_indirect") {
+          for (const sub of n) {
+            if (typeof sub === "string" && sub[0] === "$" && tables.has(sub) && !tables.get(sub).used) {
+              tables.get(sub).used = true;
+              changed = true;
+            }
+          }
+        }
+        if (op === "type" && types.has(ref) && !types.get(ref).used) {
+          types.get(ref).used = true;
+          changed = true;
+        }
+      });
+    }
+  }
+  const result = ["module"];
+  for (const node of ast.slice(1)) {
+    if (!Array.isArray(node)) {
+      result.push(node);
+      continue;
+    }
+    const kind = node[0];
+    if (kind === "func") {
+      const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
+      const entry = name2 ? funcs.get(name2) : [...funcs.values()].find((e) => e.node === node);
+      if (entry?.used) result.push(node);
+    } else if (kind === "global") {
+      const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
+      const entry = name2 ? globals.get(name2) : [...globals.values()].find((e) => e.node === node);
+      if (entry?.used) result.push(node);
+    } else if (kind === "type") {
+      result.push(node);
+    } else {
+      result.push(node);
+    }
+  }
+  return result;
+};
+var FOLDABLE = {
+  // i32
+  "i32.add": (a, b) => a + b | 0,
+  "i32.sub": (a, b) => a - b | 0,
+  "i32.mul": (a, b) => Math.imul(a, b),
+  "i32.div_s": (a, b) => b !== 0 ? a / b | 0 : null,
+  "i32.div_u": (a, b) => b !== 0 ? (a >>> 0) / (b >>> 0) | 0 : null,
+  "i32.rem_s": (a, b) => b !== 0 ? a % b | 0 : null,
+  "i32.rem_u": (a, b) => b !== 0 ? (a >>> 0) % (b >>> 0) | 0 : null,
+  "i32.and": (a, b) => a & b,
+  "i32.or": (a, b) => a | b,
+  "i32.xor": (a, b) => a ^ b,
+  "i32.shl": (a, b) => a << (b & 31),
+  "i32.shr_s": (a, b) => a >> (b & 31),
+  "i32.shr_u": (a, b) => a >>> (b & 31),
+  "i32.rotl": (a, b) => {
+    b &= 31;
+    return a << b | a >>> 32 - b | 0;
+  },
+  "i32.rotr": (a, b) => {
+    b &= 31;
+    return a >>> b | a << 32 - b | 0;
+  },
+  "i32.eq": (a, b) => a === b ? 1 : 0,
+  "i32.ne": (a, b) => a !== b ? 1 : 0,
+  "i32.lt_s": (a, b) => a < b ? 1 : 0,
+  "i32.lt_u": (a, b) => a >>> 0 < b >>> 0 ? 1 : 0,
+  "i32.gt_s": (a, b) => a > b ? 1 : 0,
+  "i32.gt_u": (a, b) => a >>> 0 > b >>> 0 ? 1 : 0,
+  "i32.le_s": (a, b) => a <= b ? 1 : 0,
+  "i32.le_u": (a, b) => a >>> 0 <= b >>> 0 ? 1 : 0,
+  "i32.ge_s": (a, b) => a >= b ? 1 : 0,
+  "i32.ge_u": (a, b) => a >>> 0 >= b >>> 0 ? 1 : 0,
+  "i32.eqz": (a) => a === 0 ? 1 : 0,
+  "i32.clz": (a) => Math.clz32(a),
+  "i32.ctz": (a) => a === 0 ? 32 : 31 - Math.clz32(a & -a),
+  "i32.popcnt": (a) => {
+    let c = 0;
+    while (a) {
+      c += a & 1;
+      a >>>= 1;
+    }
+    return c;
+  },
+  "i32.wrap_i64": (a) => Number(BigInt.asIntN(32, a)),
+  // i64 (using BigInt)
+  "i64.add": (a, b) => BigInt.asIntN(64, a + b),
+  "i64.sub": (a, b) => BigInt.asIntN(64, a - b),
+  "i64.mul": (a, b) => BigInt.asIntN(64, a * b),
+  "i64.div_s": (a, b) => b !== 0n ? BigInt.asIntN(64, a / b) : null,
+  "i64.div_u": (a, b) => b !== 0n ? BigInt.asUintN(64, BigInt.asUintN(64, a) / BigInt.asUintN(64, b)) : null,
+  "i64.rem_s": (a, b) => b !== 0n ? BigInt.asIntN(64, a % b) : null,
+  "i64.rem_u": (a, b) => b !== 0n ? BigInt.asUintN(64, BigInt.asUintN(64, a) % BigInt.asUintN(64, b)) : null,
+  "i64.and": (a, b) => BigInt.asIntN(64, a & b),
+  "i64.or": (a, b) => BigInt.asIntN(64, a | b),
+  "i64.xor": (a, b) => BigInt.asIntN(64, a ^ b),
+  "i64.shl": (a, b) => BigInt.asIntN(64, a << (b & 63n)),
+  "i64.shr_s": (a, b) => BigInt.asIntN(64, a >> (b & 63n)),
+  "i64.shr_u": (a, b) => BigInt.asUintN(64, BigInt.asUintN(64, a) >> (b & 63n)),
+  "i64.eq": (a, b) => a === b ? 1 : 0,
+  "i64.ne": (a, b) => a !== b ? 1 : 0,
+  "i64.lt_s": (a, b) => a < b ? 1 : 0,
+  "i64.lt_u": (a, b) => BigInt.asUintN(64, a) < BigInt.asUintN(64, b) ? 1 : 0,
+  "i64.gt_s": (a, b) => a > b ? 1 : 0,
+  "i64.gt_u": (a, b) => BigInt.asUintN(64, a) > BigInt.asUintN(64, b) ? 1 : 0,
+  "i64.le_s": (a, b) => a <= b ? 1 : 0,
+  "i64.le_u": (a, b) => BigInt.asUintN(64, a) <= BigInt.asUintN(64, b) ? 1 : 0,
+  "i64.ge_s": (a, b) => a >= b ? 1 : 0,
+  "i64.ge_u": (a, b) => BigInt.asUintN(64, a) >= BigInt.asUintN(64, b) ? 1 : 0,
+  "i64.eqz": (a) => a === 0n ? 1 : 0,
+  "i64.extend_i32_s": (a) => BigInt(a),
+  "i64.extend_i32_u": (a) => BigInt(a >>> 0),
+  // f32/f64 - be careful with NaN/precision
+  "f32.add": (a, b) => Math.fround(a + b),
+  "f32.sub": (a, b) => Math.fround(a - b),
+  "f32.mul": (a, b) => Math.fround(a * b),
+  "f32.div": (a, b) => Math.fround(a / b),
+  "f32.neg": (a) => Math.fround(-a),
+  "f32.abs": (a) => Math.fround(Math.abs(a)),
+  "f32.sqrt": (a) => Math.fround(Math.sqrt(a)),
+  "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)),
+  "f64.add": (a, b) => a + b,
+  "f64.sub": (a, b) => a - b,
+  "f64.mul": (a, b) => a * b,
+  "f64.div": (a, b) => a / b,
+  "f64.neg": (a) => -a,
+  "f64.abs": (a) => Math.abs(a),
+  "f64.sqrt": (a) => Math.sqrt(a),
+  "f64.ceil": (a) => Math.ceil(a),
+  "f64.floor": (a) => Math.floor(a),
+  "f64.trunc": (a) => Math.trunc(a),
+  "f64.nearest": (a) => Math.round(a)
+};
+var getConst = (node) => {
+  if (!Array.isArray(node) || node.length !== 2) return null;
+  const [op, val] = node;
+  if (op === "i32.const") return { type: "i32", value: Number(val) | 0 };
+  if (op === "i64.const") return { type: "i64", value: BigInt(val) };
+  if (op === "f32.const") return { type: "f32", value: Math.fround(Number(val)) };
+  if (op === "f64.const") return { type: "f64", value: Number(val) };
+  return null;
+};
+var makeConst = (type, value) => {
+  if (type === "i32") return ["i32.const", value | 0];
+  if (type === "i64") return ["i64.const", value];
+  if (type === "f32") return ["f32.const", Math.fround(value)];
+  if (type === "f64") return ["f64.const", value];
+  return null;
+};
+var fold = (ast) => {
+  return walkPost2(clone2(ast), (node) => {
+    if (!Array.isArray(node)) return;
+    const op = node[0];
+    const fn = FOLDABLE[op];
+    if (!fn) return;
+    if (fn.length === 1 && node.length === 2) {
+      const a = getConst(node[1]);
+      if (!a) return;
+      const result = fn(a.value);
+      if (result === null) return;
+      const resultType = op.startsWith("i64.") && !op.includes("eqz") ? "i64" : op.startsWith("f32.") ? "f32" : op.startsWith("f64.") ? "f64" : "i32";
+      return makeConst(resultType, result);
+    }
+    if (fn.length === 2 && node.length === 3) {
+      const a = getConst(node[1]);
+      const b = getConst(node[2]);
+      if (!a || !b) return;
+      const result = fn(a.value, b.value);
+      if (result === null) return;
+      const isCompare = /\.(eq|ne|[lg][te])/.test(op);
+      const resultType = isCompare ? "i32" : op.startsWith("i64.") ? "i64" : op.startsWith("f32.") ? "f32" : op.startsWith("f64.") ? "f64" : "i32";
+      return makeConst(resultType, result);
+    }
+  });
+};
+var IDENTITIES = {
+  // x + 0 → x, 0 + x → x
+  "i32.add": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 0) return b;
+    if (cb?.value === 0) return a;
+    return null;
+  },
+  "i64.add": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 0n) return b;
+    if (cb?.value === 0n) return a;
+    return null;
+  },
+  // x - 0 → x
+  "i32.sub": (a, b) => getConst(b)?.value === 0 ? a : null,
+  "i64.sub": (a, b) => getConst(b)?.value === 0n ? a : null,
+  // x * 1 → x, 1 * x → x
+  "i32.mul": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 1) return b;
+    if (cb?.value === 1) return a;
+    return null;
+  },
+  "i64.mul": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 1n) return b;
+    if (cb?.value === 1n) return a;
+    return null;
+  },
+  // x / 1 → x
+  "i32.div_s": (a, b) => getConst(b)?.value === 1 ? a : null,
+  "i32.div_u": (a, b) => getConst(b)?.value === 1 ? a : null,
+  "i64.div_s": (a, b) => getConst(b)?.value === 1n ? a : null,
+  "i64.div_u": (a, b) => getConst(b)?.value === 1n ? a : null,
+  // x & -1 → x, -1 & x → x (all bits set)
+  "i32.and": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === -1) return b;
+    if (cb?.value === -1) return a;
+    return null;
+  },
+  "i64.and": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === -1n) return b;
+    if (cb?.value === -1n) return a;
+    return null;
+  },
+  // x | 0 → x, 0 | x → x
+  "i32.or": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 0) return b;
+    if (cb?.value === 0) return a;
+    return null;
+  },
+  "i64.or": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 0n) return b;
+    if (cb?.value === 0n) return a;
+    return null;
+  },
+  // x ^ 0 → x, 0 ^ x → x
+  "i32.xor": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 0) return b;
+    if (cb?.value === 0) return a;
+    return null;
+  },
+  "i64.xor": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 0n) return b;
+    if (cb?.value === 0n) return a;
+    return null;
+  },
+  // x << 0 → x, x >> 0 → x
+  "i32.shl": (a, b) => getConst(b)?.value === 0 ? a : null,
+  "i32.shr_s": (a, b) => getConst(b)?.value === 0 ? a : null,
+  "i32.shr_u": (a, b) => getConst(b)?.value === 0 ? a : null,
+  "i64.shl": (a, b) => getConst(b)?.value === 0n ? a : null,
+  "i64.shr_s": (a, b) => getConst(b)?.value === 0n ? a : null,
+  "i64.shr_u": (a, b) => getConst(b)?.value === 0n ? a : null
+  // f + 0 → x (careful with -0.0, skip for floats)
+  // f * 1 → x (careful with NaN, skip for floats)
+};
+var identity = (ast) => {
+  return walkPost2(clone2(ast), (node) => {
+    if (!Array.isArray(node) || node.length !== 3) return;
+    const fn = IDENTITIES[node[0]];
+    if (!fn) return;
+    const result = fn(node[1], node[2]);
+    if (result === null) return;
+    return result;
+  });
+};
+var strength = (ast) => {
+  return walkPost2(clone2(ast), (node) => {
+    if (!Array.isArray(node) || node.length !== 3) return;
+    const [op, a, b] = node;
+    if (op === "i32.mul") {
+      const cb = getConst(b);
+      if (cb && cb.value > 0 && (cb.value & cb.value - 1) === 0) {
+        const shift = Math.log2(cb.value);
+        if (Number.isInteger(shift)) return ["i32.shl", a, ["i32.const", shift]];
+      }
+      const ca = getConst(a);
+      if (ca && ca.value > 0 && (ca.value & ca.value - 1) === 0) {
+        const shift = Math.log2(ca.value);
+        if (Number.isInteger(shift)) return ["i32.shl", b, ["i32.const", shift]];
+      }
+    }
+    if (op === "i64.mul") {
+      const cb = getConst(b);
+      if (cb && cb.value > 0n && (cb.value & cb.value - 1n) === 0n) {
+        const shift = BigInt(cb.value.toString(2).length - 1);
+        return ["i64.shl", a, ["i64.const", shift]];
+      }
+      const ca = getConst(a);
+      if (ca && ca.value > 0n && (ca.value & ca.value - 1n) === 0n) {
+        const shift = BigInt(ca.value.toString(2).length - 1);
+        return ["i64.shl", b, ["i64.const", shift]];
+      }
+    }
+    if (op === "i32.div_u") {
+      const cb = getConst(b);
+      if (cb && cb.value > 0 && (cb.value & cb.value - 1) === 0) {
+        const shift = Math.log2(cb.value);
+        if (Number.isInteger(shift)) return ["i32.shr_u", a, ["i32.const", shift]];
+      }
+    }
+    if (op === "i64.div_u") {
+      const cb = getConst(b);
+      if (cb && cb.value > 0n && (cb.value & cb.value - 1n) === 0n) {
+        const shift = BigInt(cb.value.toString(2).length - 1);
+        return ["i64.shr_u", a, ["i64.const", shift]];
+      }
+    }
+    if (op === "i32.rem_u") {
+      const cb = getConst(b);
+      if (cb && cb.value > 0 && (cb.value & cb.value - 1) === 0) {
+        return ["i32.and", a, ["i32.const", cb.value - 1]];
+      }
+    }
+    if (op === "i64.rem_u") {
+      const cb = getConst(b);
+      if (cb && cb.value > 0n && (cb.value & cb.value - 1n) === 0n) {
+        return ["i64.and", a, ["i64.const", cb.value - 1n]];
+      }
+    }
+  });
+};
+var branch = (ast) => {
+  return walkPost2(clone2(ast), (node) => {
+    if (!Array.isArray(node)) return;
+    const op = node[0];
+    if (op === "if") {
+      let condIdx = 1;
+      while (condIdx < node.length) {
+        const child = node[condIdx];
+        if (Array.isArray(child) && (child[0] === "then" || child[0] === "else" || child[0] === "result" || child[0] === "param")) {
+          condIdx++;
+          continue;
+        }
+        break;
+      }
+      const cond = node[condIdx];
+      const c = getConst(cond);
+      if (!c) return;
+      let thenBranch = null, elseBranch = null;
+      for (let i = condIdx + 1; i < node.length; i++) {
+        const child = node[i];
+        if (Array.isArray(child)) {
+          if (child[0] === "then") thenBranch = child;
+          else if (child[0] === "else") elseBranch = child;
+        }
+      }
+      if (c.value !== 0 && c.value !== 0n) {
+        if (thenBranch && thenBranch.length > 1) {
+          const contents = thenBranch.slice(1);
+          if (contents.length === 1) return contents[0];
+          return ["block", ...contents];
+        }
+        return ["nop"];
+      } else {
+        if (elseBranch && elseBranch.length > 1) {
+          const contents = elseBranch.slice(1);
+          if (contents.length === 1) return contents[0];
+          return ["block", ...contents];
+        }
+        return ["nop"];
+      }
+    }
+    if (op === "br_if" && node.length >= 3) {
+      const cond = node[node.length - 1];
+      const c = getConst(cond);
+      if (!c) return;
+      if (c.value === 0 || c.value === 0n) return ["nop"];
+      return ["br", node[1]];
+    }
+    if (op === "select" && node.length >= 4) {
+      const cond = node[node.length - 1];
+      const c = getConst(cond);
+      if (!c) return;
+      if (c.value === 0 || c.value === 0n) return node[2];
+      return node[1];
+    }
+  });
+};
+var TERMINATORS = /* @__PURE__ */ new Set(["unreachable", "return", "br", "br_table"]);
+var deadcode = (ast) => {
+  const result = clone2(ast);
+  walk2(result, (node) => {
+    if (!Array.isArray(node)) return;
+    const kind = node[0];
+    if (kind === "func" || kind === "block" || kind === "loop") {
+      eliminateDeadInBlock(node);
+    }
+    if (kind === "if") {
+      for (let i = 1; i < node.length; i++) {
+        if (Array.isArray(node[i]) && (node[i][0] === "then" || node[i][0] === "else")) {
+          eliminateDeadInBlock(node[i]);
+        }
+      }
+    }
+  });
+  return result;
+};
+var eliminateDeadInBlock = (block) => {
+  let terminated = false;
+  let firstTerminator = -1;
+  for (let i = 1; i < block.length; i++) {
+    const node = block[i];
+    if (Array.isArray(node)) {
+      const op = node[0];
+      if (op === "param" || op === "result" || op === "local" || op === "type" || op === "export") continue;
+      if (terminated) {
+        if (firstTerminator === -1) firstTerminator = i;
+      }
+      if (TERMINATORS.has(op)) {
+        terminated = true;
+        firstTerminator = i + 1;
+      }
+    } else if (typeof node === "string") {
+      if (terminated) {
+        if (firstTerminator === -1) firstTerminator = i;
+      }
+      if (TERMINATORS.has(node)) {
+        terminated = true;
+        firstTerminator = i + 1;
+      }
+    }
+  }
+  if (firstTerminator > 0 && firstTerminator < block.length) {
+    block.splice(firstTerminator);
+  }
+};
+var localReuse = (ast) => {
+  const result = clone2(ast);
+  walk2(result, (node) => {
+    if (!Array.isArray(node) || node[0] !== "func") return;
+    const localDecls = [];
+    const localTypes = /* @__PURE__ */ new Map();
+    const usedLocals = /* @__PURE__ */ new Set();
+    for (let i = 1; i < node.length; i++) {
+      const sub = node[i];
+      if (!Array.isArray(sub)) continue;
+      if (sub[0] === "local") {
+        localDecls.push({ idx: i, node: sub });
+        if (typeof sub[1] === "string" && sub[1][0] === "$") {
+          localTypes.set(sub[1], sub[2]);
+        }
+      }
+      if (sub[0] === "param") {
+        if (typeof sub[1] === "string" && sub[1][0] === "$") {
+          localTypes.set(sub[1], sub[2]);
+          usedLocals.add(sub[1]);
+        }
+      }
+    }
+    walk2(node, (n) => {
+      if (!Array.isArray(n)) return;
+      const op = n[0];
+      if (op === "local.get" || op === "local.set" || op === "local.tee") {
+        const ref = n[1];
+        if (typeof ref === "string") usedLocals.add(ref);
+      }
+    });
+    for (let i = localDecls.length - 1; i >= 0; i--) {
+      const { idx, node: decl } = localDecls[i];
+      const name2 = typeof decl[1] === "string" && decl[1][0] === "$" ? decl[1] : null;
+      if (name2 && !usedLocals.has(name2)) {
+        node.splice(idx, 1);
+      }
+    }
+  });
+  return result;
+};
+var propagate = (ast) => {
+  const result = clone2(ast);
+  walk2(result, (node) => {
+    if (!Array.isArray(node) || node[0] !== "func") return;
+    const constLocals = /* @__PURE__ */ new Map();
+    const processBlock = (block, startIdx = 1) => {
+      for (let i = startIdx; i < block.length; i++) {
+        const instr2 = block[i];
+        if (!Array.isArray(instr2)) continue;
+        const op = instr2[0];
+        if (op === "local.set" && instr2.length === 3) {
+          const local = instr2[1];
+          const val = instr2[2];
+          const c = getConst(val);
+          if (c && typeof local === "string") {
+            constLocals.set(local, val);
+          } else if (typeof local === "string") {
+            constLocals.delete(local);
+          }
+        } else if (op === "local.tee" && instr2.length === 3) {
+          const local = instr2[1];
+          const val = instr2[2];
+          const c = getConst(val);
+          if (c && typeof local === "string") {
+            constLocals.set(local, val);
+          } else if (typeof local === "string") {
+            constLocals.delete(local);
+          }
+        } else if (op === "local.get" && instr2.length === 2) {
+          const local = instr2[1];
+          if (typeof local === "string" && constLocals.has(local)) {
+            const constVal = constLocals.get(local);
+            instr2.length = 0;
+            instr2.push(...clone2(constVal));
+          }
+        } else if (op === "block" || op === "loop" || op === "if" || op === "call" || op === "call_indirect") {
+          constLocals.clear();
+        }
+        walkPost2(instr2, (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 clone2(constVal);
+          }
+        });
+      }
+    };
+    processBlock(node);
+  });
+  return result;
+};
+var inline = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  const result = clone2(ast);
+  const inlinable = /* @__PURE__ */ new Map();
+  for (const node of result.slice(1)) {
+    if (!Array.isArray(node) || node[0] !== "func") continue;
+    const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
+    if (!name2) continue;
+    let params = [];
+    let body = [];
+    let hasLocals = false;
+    let hasExport = false;
+    for (let i = 1; i < node.length; i++) {
+      const sub = node[i];
+      if (!Array.isArray(sub)) continue;
+      if (sub[0] === "param") {
+        if (typeof sub[1] === "string" && sub[1][0] === "$") {
+          params.push({ name: sub[1], type: sub[2] });
+        } else {
+          params = null;
+          break;
+        }
+      } else if (sub[0] === "local") {
+        hasLocals = true;
+      } else if (sub[0] === "export") {
+        hasExport = true;
+      } else if (sub[0] !== "result" && sub[0] !== "type") {
+        body.push(sub);
+      }
+    }
+    if (params && !hasLocals && !hasExport && params.length <= 2 && body.length === 1) {
+      const paramNames = new Set(params.map((p) => p.name));
+      let mutatesParam = false;
+      walk2(body[0], (n) => {
+        if (!Array.isArray(n)) return;
+        if ((n[0] === "local.set" || n[0] === "local.tee") && paramNames.has(n[1])) {
+          mutatesParam = true;
+        }
+      });
+      if (!mutatesParam) {
+        inlinable.set(name2, { body: body[0], params });
+      }
+    }
+  }
+  if (inlinable.size === 0) return result;
+  walkPost2(result, (node) => {
+    if (!Array.isArray(node) || node[0] !== "call") return;
+    const fname = node[1];
+    if (!inlinable.has(fname)) return;
+    const { body, params } = inlinable.get(fname);
+    const args = node.slice(2);
+    if (params.length === 0) {
+      return clone2(body);
+    }
+    const substituted = clone2(body);
+    walkPost2(substituted, (n) => {
+      if (!Array.isArray(n) || n[0] !== "local.get") return;
+      const local = n[1];
+      const paramIdx = params.findIndex((p) => p.name === local);
+      if (paramIdx !== -1 && args[paramIdx]) {
+        return clone2(args[paramIdx]);
+      }
+    });
+    return substituted;
+  });
+  return result;
+};
+function optimize(ast, opts = true) {
+  if (typeof ast === "string") ast = parse_default(ast);
+  ast = clone2(ast);
+  opts = normalize3(opts);
+  if (opts.fold) ast = fold(ast);
+  if (opts.identity) ast = identity(ast);
+  if (opts.strength) ast = strength(ast);
+  if (opts.branch) ast = branch(ast);
+  if (opts.propagate) ast = propagate(ast);
+  if (opts.inline) ast = inline(ast);
+  if (opts.deadcode) ast = deadcode(ast);
+  if (opts.locals) ast = localReuse(ast);
+  if (opts.treeshake) ast = treeshake(ast);
+  return ast;
+}
+
 // watr.js
 var PUA = "\uE000";
 var instrType = (op) => {
@@ -2587,11 +3395,11 @@ var exprType = (node, ctx = {}) => {
   if (op === "call" && ctx.funcs?.[args[0]]) return ctx.funcs[args[0]].result?.[0];
   return null;
 };
-function walk2(node, fn) {
+function walk3(node, fn) {
   node = fn(node);
   if (Array.isArray(node)) {
     for (let i = 0; i < node.length; i++) {
-      let child = walk2(node[i], fn);
+      let child = walk3(node[i], fn);
       if (child?._splice) node.splice(i, 1, ...child), i += child.length - 1;
       else node[i] = child;
     }
@@ -2601,7 +3409,7 @@ function walk2(node, fn) {
 function inferImports(ast, funcs) {
   const imports = [];
   const importMap = /* @__PURE__ */ new Map();
-  walk2(ast, (node) => {
+  walk3(ast, (node) => {
     if (!Array.isArray(node)) return node;
     if (node[0] === "call" && typeof node[1] === "function") {
       const fn = node[1];
@@ -2641,7 +3449,7 @@ function compile2(source, ...values) {
     let ast = parse_default(src);
     const funcsToImport = [];
     let idx = 0;
-    ast = walk2(ast, (node) => {
+    ast = walk3(ast, (node) => {
       if (node === PUA) {
         const value = values[idx++];
         if (typeof value === "function") {
@@ -2679,12 +3487,15 @@ function compile2(source, ...values) {
       }
     }
     if (opts.polyfill) ast = polyfill(ast, opts.polyfill);
+    if (opts.optimize) ast = optimize(ast, opts.optimize);
     const binary = compile(ast);
     if (importObjs) binary._imports = importObjs;
     return binary;
   }
-  if (opts.polyfill) {
-    const ast = polyfill(source, opts.polyfill);
+  if (opts.polyfill || opts.optimize) {
+    let ast = typeof source === "string" ? parse_default(source) : source;
+    if (opts.polyfill) ast = polyfill(ast, opts.polyfill);
+    if (opts.optimize) ast = optimize(ast, opts.optimize);
     return compile(ast);
   }
   return compile(source);
@@ -2699,6 +3510,7 @@ var watr_default = watr;
 export {
   compile2 as compile,
   watr_default as default,
+  optimize,
   parse_default as parse,
   polyfill,
   print,