watr 4.3.3 → 4.4.0

package/dist/watr.js

@@ -1529,7 +1529,7 @@ var build = [
   // (elem (table idx)? (offset expr)|(expr) elem*) - active
   // ref: https://webassembly.github.io/spec/core/binary/modules.html#element-section
   (parts, ctx) => {
-    let passive = 0, declare = 0, elexpr = 0, nofunc = 0, tabidx, offset, rt;
+    let passive = 0, declare = 0, elexpr = 0, nofunc = 0, tabidx, offset2, rt;
     if (parts[0] === "declare") parts.shift(), declare = 1;
     if (parts[0]?.[0] === "table") {
       [, tabidx] = parts.shift();
@@ -1538,9 +1538,9 @@ var build = [
       tabidx = id(parts.shift(), ctx.table);
     }
     if (parts[0]?.[0] === "offset" || Array.isArray(parts[0]) && parts[0][0] !== "item" && !parts[0][0].startsWith("ref")) {
-      offset = parts.shift();
-      if (offset[0] === "offset") [, offset] = offset;
-      offset = expr(offset, ctx);
+      offset2 = parts.shift();
+      if (offset2[0] === "offset") [, offset2] = offset2;
+      offset2 = expr(offset2, ctx);
     } else if (!declare) passive = 1;
     if (TYPE[parts[0]] || parts[0]?.[0] === "ref") rt = reftype(parts.shift(), ctx);
     else if (parts[0] === "func") rt = [TYPE[parts.shift()]];
@@ -1556,19 +1556,19 @@ var build = [
     return [
       mode,
       ...// 0b000 e:expr y*:vec(funcidx)                     | type=(ref func), init ((ref.func y)end)*, active (table=0,offset=e)
-      mode === 0 ? offset : (
+      mode === 0 ? offset2 : (
         // 0b001 et:elkind y*:vec(funcidx)                  | type=0x00, init ((ref.func y)end)*, passive
         mode === 1 ? [0] : (
           // 0b010 x:tabidx e:expr et:elkind y*:vec(funcidx)  | type=0x00, init ((ref.func y)end)*, active (table=x,offset=e)
-          mode === 2 ? [...uleb(tabidx || 0), ...offset, 0] : (
+          mode === 2 ? [...uleb(tabidx || 0), ...offset2, 0] : (
             // 0b011 et:elkind y*:vec(funcidx)                  | type=0x00, init ((ref.func y)end)*, passive declare
             mode === 3 ? [0] : (
               // 0b100 e:expr el*:vec(expr)                       | type=(ref null func), init el*, active (table=0, offset=e)
-              mode === 4 ? offset : (
+              mode === 4 ? offset2 : (
                 // 0b101 et:reftype el*:vec(expr)                   | type=et, init el*, passive
                 mode === 5 ? rt : (
                   // 0b110 x:tabidx e:expr et:reftype el*:vec(expr)   | type=et, init el*, active (table=x, offset=e)
-                  mode === 6 ? [...uleb(tabidx || 0), ...offset, ...rt] : (
+                  mode === 6 ? [...uleb(tabidx || 0), ...offset2, ...rt] : (
                     // 0b111 et:reftype el*:vec(expr)                   | type=et, init el*, passive declare
                     rt
                   )
@@ -1623,7 +1623,7 @@ var build = [
   // (data (global.get $x) "\aa" "\bb"?)
   // (data (i8 1 2 3) ...) numeric values (WAT numeric values, Phase 2)
   (inits, ctx) => {
-    let offset, memidx = 0;
+    let offset2, memidx = 0;
     if (inits[0]?.[0] === "memory") {
       [, memidx] = inits.shift();
       memidx = id(memidx, ctx.memory);
@@ -1631,15 +1631,15 @@ var build = [
       memidx = id(inits.shift(), ctx.memory);
     }
     if (Array.isArray(inits[0]) && typeof inits[0]?.[0] === "string") {
-      offset = inits.shift();
-      if (offset[0] === "offset") [, offset] = offset;
-      offset ?? err("Bad offset", offset);
+      offset2 = inits.shift();
+      if (offset2[0] === "offset") [, offset2] = offset2;
+      offset2 ?? err("Bad offset", offset2);
     }
     return [
       ...// active: 2, x=memidx, e=expr
-      memidx ? [2, ...uleb(memidx), ...expr(offset, ctx)] : (
+      memidx ? [2, ...uleb(memidx), ...expr(offset2, ctx)] : (
         // active: 0, e=expr
-        offset ? [0, ...expr(offset, ctx)] : (
+        offset2 ? [0, ...expr(offset2, ctx)] : (
           // passive: 1
           [1]
         )
@@ -1854,12 +1854,12 @@ var expr = (node, ctx) => instr(normalize([node], ctx), ctx);
 var id = (nm, list, n) => (n = isId(nm) ? list[nm] : +nm, n in list ? n : err(`Unknown ${list.name} ${nm}`));
 var blockid = (nm, block, i) => (i = isId(nm) ? block.length - block[nm] : +nm, isNaN(i) || i > block.length ? err(`Bad label ${nm}`) : i);
 var memarg = (args) => {
-  let align2, offset, k, v;
-  while (isMemParam(args[0])) [k, v] = args.shift().split("="), k === "offset" ? offset = +v : k === "align" ? align2 = +v : err(`Unknown param ${k}=${v}`);
-  if (offset < 0 || offset > 4294967295) err(`Bad offset ${offset}`);
+  let align2, offset2, k, v;
+  while (isMemParam(args[0])) [k, v] = args.shift().split("="), k === "offset" ? offset2 = +v : k === "align" ? align2 = +v : err(`Unknown param ${k}=${v}`);
+  if (offset2 < 0 || offset2 > 4294967295) err(`Bad offset ${offset2}`);
   if (align2 <= 0 || align2 > 4294967295) err(`Bad align ${align2}`);
   if (align2) (align2 = Math.log2(align2)) % 1 && err(`Bad align ${align2}`);
-  return [align2, offset];
+  return [align2, offset2];
 };
 var memargEnc = (nodes, op, memIdx = 0) => {
   const [a, o] = memarg(nodes), alignVal = (a ?? align(op)) | (memIdx && 64);
@@ -2345,7 +2345,7 @@ var i31ref = (ast, ctx) => {
 };
 transforms.i31ref = i31ref;
 var extended_const = (ast, ctx) => {
-  const globals = {};
+  const globals2 = {};
   walk(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "global") return;
     const id2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
@@ -2354,7 +2354,7 @@ var extended_const = (ast, ctx) => {
       const init = node[i];
       if (!Array.isArray(init)) continue;
       if (init[0] === "i32.const" || init[0] === "i64.const" || init[0] === "f32.const" || init[0] === "f64.const") {
-        globals[id2] = { type: init[0].split(".")[0], value: init[1] };
+        globals2[id2] = { type: init[0].split(".")[0], value: init[1] };
         break;
       }
     }
@@ -2362,8 +2362,8 @@ var extended_const = (ast, ctx) => {
   const evalConst = (node) => {
     if (!Array.isArray(node)) return node;
     const op = node[0];
-    if (op === "global.get" && globals[node[1]]) {
-      const g = globals[node[1]];
+    if (op === "global.get" && globals2[node[1]]) {
+      const g = globals2[node[1]];
       return [`${g.type}.const`, g.value];
     }
     if (op === "i32.add" || op === "i64.add") {
@@ -2516,11 +2516,11 @@ var gc = (ast, ctx) => {
     return size;
   };
   const fieldOffset = (typeDef, fieldIdx) => {
-    let offset = 4;
+    let offset2 = 4;
     for (let i = 0; i < fieldIdx; i++) {
-      offset += TYPE_SIZES[typeDef.fields[i].type] || 4;
+      offset2 += TYPE_SIZES[typeDef.fields[i].type] || 4;
     }
-    return offset;
+    return offset2;
   };
   const findFieldIdx = (typeDef, fieldName) => {
     for (let i = 0; i < typeDef.fields.length; i++) {
@@ -2582,17 +2582,17 @@ var gc = (ast, ctx) => {
       if (node[0] === "struct.new") {
         for (let i = 0; i < typeDef.fields.length; i++) {
           const f = typeDef.fields[i];
-          const offset = fieldOffset(typeDef, i);
+          const offset2 = fieldOffset(typeDef, i);
           const storeOp = f.type === "i64" ? "i64.store" : f.type === "f32" ? "f32.store" : f.type === "f64" ? "f64.store" : "i32.store";
-          stores.push([storeOp, ["i32.add", ["local.get", ptrLocal], ["i32.const", offset]], args[i] || [`${f.type}.const`, 0]]);
+          stores.push([storeOp, ["i32.add", ["local.get", ptrLocal], ["i32.const", offset2]], args[i] || [`${f.type}.const`, 0]]);
         }
       } else {
         for (let i = 0; i < typeDef.fields.length; i++) {
           const f = typeDef.fields[i];
-          const offset = fieldOffset(typeDef, i);
+          const offset2 = fieldOffset(typeDef, i);
           const storeOp = f.type === "i64" ? "i64.store" : f.type === "f32" ? "f32.store" : f.type === "f64" ? "f64.store" : "i32.store";
           const zero = f.type === "i64" ? ["i64.const", 0n] : f.type === "f32" ? ["f32.const", 0] : f.type === "f64" ? ["f64.const", 0] : ["i32.const", 0];
-          stores.push([storeOp, ["i32.add", ["local.get", ptrLocal], ["i32.const", offset]], zero]);
+          stores.push([storeOp, ["i32.add", ["local.get", ptrLocal], ["i32.const", offset2]], zero]);
         }
       }
       stores.push(["local.get", ptrLocal]);
@@ -2607,9 +2607,9 @@ var gc = (ast, ctx) => {
       const fieldIdx = typeof fieldId === "string" && fieldId[0] === "$" ? findFieldIdx(typeDef, fieldId) : parseInt(fieldId);
       if (fieldIdx < 0) return;
       const f = typeDef.fields[fieldIdx];
-      const offset = fieldOffset(typeDef, fieldIdx);
+      const offset2 = fieldOffset(typeDef, fieldIdx);
       const loadOp = f.type === "i64" ? "i64.load" : f.type === "f32" ? "f32.load" : f.type === "f64" ? "f64.load" : "i32.load";
-      parent[idx] = [loadOp, ["i32.add", ref, ["i32.const", offset]]];
+      parent[idx] = [loadOp, ["i32.add", ref, ["i32.const", offset2]]];
     }
     if (node[0] === "struct.set") {
       const typeId = node[1];
@@ -2621,9 +2621,9 @@ var gc = (ast, ctx) => {
       const fieldIdx = typeof fieldId === "string" && fieldId[0] === "$" ? findFieldIdx(typeDef, fieldId) : parseInt(fieldId);
       if (fieldIdx < 0) return;
       const f = typeDef.fields[fieldIdx];
-      const offset = fieldOffset(typeDef, fieldIdx);
+      const offset2 = fieldOffset(typeDef, fieldIdx);
       const storeOp = f.type === "i64" ? "i64.store" : f.type === "f32" ? "f32.store" : f.type === "f64" ? "f64.store" : "i32.store";
-      parent[idx] = [storeOp, ["i32.add", ref, ["i32.const", offset]], val];
+      parent[idx] = [storeOp, ["i32.add", ref, ["i32.const", offset2]], val];
     }
     if (node[0] === "array.new" || node[0] === "array.new_default") {
       const typeId = node[1];
@@ -2876,10 +2876,47 @@ var OPTS = {
   // simplify constant branches
   propagate: true,
   // constant propagation through locals
-  inline: true
+  inline: true,
   // inline tiny functions
+  vacuum: true,
+  // remove nops, drop-of-pure, empty branches
+  peephole: true,
+  // x-x→0, x&0→0, etc.
+  globals: true,
+  // propagate immutable global constants
+  offset: true,
+  // fold add+const into load/store offset
+  unbranch: true,
+  // remove redundant br at end of own block
+  stripmut: true,
+  // strip mut from never-written globals
+  brif: true,
+  // if-then-br → br_if
+  foldarms: true,
+  // merge identical trailing if arms
+  // minify: true,    // NOTE: disabled — renaming $ids has no binary-size effect
+  // without a names section, and risks local-name collisions.
+  dedupe: true,
+  // eliminate duplicate functions
+  reorder: true,
+  // put hot functions first for smaller LEBs
+  dedupTypes: true,
+  // merge identical type definitions
+  packData: true,
+  // trim trailing zeros, merge adjacent data segments
+  minifyImports: false
+  // shorten import names — enable only when you control the host
 };
 var ALL2 = Object.keys(OPTS);
+var equal = (a, b) => {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (typeof a === "bigint") return a === b;
+  if (!Array.isArray(a) || !Array.isArray(b)) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (!equal(a[i], b[i])) return false;
+  return true;
+};
 var normalize3 = (opts) => {
   if (opts === true) return { ...OPTS };
   if (opts === false) return {};
@@ -2910,157 +2947,134 @@ var walkPost2 = (node, fn, parent, idx) => {
   const result = fn(node, parent, idx);
   return result !== void 0 ? result : node;
 };
+var parseIf = (node) => {
+  let condIdx = 1;
+  while (condIdx < node.length) {
+    const c = node[condIdx];
+    if (Array.isArray(c) && (c[0] === "then" || c[0] === "else" || c[0] === "result" || c[0] === "param")) {
+      condIdx++;
+      continue;
+    }
+    break;
+  }
+  let thenBranch = null, elseBranch = null;
+  for (let i = condIdx + 1; i < node.length; i++) {
+    const c = node[i];
+    if (!Array.isArray(c)) continue;
+    if (c[0] === "then") thenBranch = c;
+    else if (c[0] === "else") elseBranch = c;
+  }
+  return { condIdx, cond: node[condIdx], thenBranch, elseBranch };
+};
 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;
+  const funcs = /* @__PURE__ */ new Map(), globals2 = /* @__PURE__ */ new Map(), types = /* @__PURE__ */ new Map();
+  const tables = /* @__PURE__ */ new Map(), memories = /* @__PURE__ */ new Map();
+  const nodeMap = /* @__PURE__ */ new Map();
+  const register = (map, node, idx, isImport = false) => {
+    const named = typeof node[1] === "string" && node[1][0] === "$";
+    const name2 = named ? node[1] : idx;
+    const inlineExported = !isImport && node.some((s) => Array.isArray(s) && s[0] === "export");
+    const entry = { node, idx, used: inlineExported, isImport };
+    map.set(name2, entry);
+    if (named) map.set(idx, entry);
+    nodeMap.set(node, entry);
+    return entry;
+  };
+  let funcIdx = 0, globalIdx = 0, typeIdx = 0, tableIdx = 0, memIdx = 0;
+  const elems = [], exports = [], starts = [];
   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") {
+    if (kind === "type") register(types, node, typeIdx++);
+    else if (kind === "func") register(funcs, node, funcIdx++);
+    else if (kind === "global") register(globals2, node, globalIdx++);
+    else if (kind === "table") register(tables, node, tableIdx++);
+    else if (kind === "memory") register(memories, node, 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++;
-        }
+        if (!Array.isArray(sub)) continue;
+        if (sub[0] === "func") register(funcs, sub, funcIdx++, true);
+        else if (sub[0] === "global") register(globals2, sub, globalIdx++, true);
+        else if (sub[0] === "table") register(tables, sub, tableIdx++, true);
+        else if (sub[0] === "memory") register(memories, sub, memIdx++, true);
       }
-    } else if (kind === "export") {
-      exports.push(node);
-    } else if (kind === "start") {
-      starts.push(node);
-    }
+    } else if (kind === "export") exports.push(node);
+    else if (kind === "start") starts.push(node);
+    else if (kind === "elem") elems.push(node);
   }
+  const work = [];
+  const enqueue = (entry) => {
+    if (entry && !entry.scanned) work.push(entry);
+  };
+  const markFunc = (ref) => {
+    const e = funcs.get(ref);
+    if (!e) return;
+    if (!e.used) e.used = true;
+    enqueue(e);
+  };
+  const markGlobal = (ref) => {
+    const e = globals2.get(ref);
+    if (e) e.used = true;
+  };
+  const markTable = (ref) => {
+    const e = tables.get(ref);
+    if (e) e.used = true;
+  };
+  const markMemory = (ref) => {
+    const e = memories.get(ref);
+    if (e) e.used = true;
+  };
+  const markType = (ref) => {
+    const e = types.get(ref);
+    if (e) e.used = true;
+  };
   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;
+      if (kind === "func") markFunc(ref);
+      else if (kind === "global") markGlobal(ref);
+      else if (kind === "table") markTable(ref);
+      else if (kind === "memory") markMemory(ref);
     }
   }
   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;
+    markFunc(ref);
   }
-  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;
-      }
-    }
+  for (const elem of elems) {
+    walk2(elem, (n) => {
+      if (Array.isArray(n) && n[0] === "ref.func") markFunc(n[1]);
+      else if (typeof n === "string" && n[0] === "$") markFunc(n);
+    });
   }
-  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 m of [funcs, globals2, tables, memories]) for (const e of m.values()) if (e.used) enqueue(e);
+  const hasAnchor = exports.length > 0 || starts.length > 0 || elems.length > 0 || work.length > 0;
+  if (!hasAnchor) {
+    for (const m of [funcs, globals2, tables, memories]) for (const e of m.values()) e.used = true;
+    return ast;
   }
-  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;
+  while (work.length) {
+    const entry = work.pop();
+    if (entry.scanned) continue;
+    entry.scanned = true;
+    if (entry.isImport) continue;
+    walk2(entry.node, (n) => {
+      if (!Array.isArray(n)) {
+        if (typeof n === "string" && n[0] === "$") markFunc(n);
+        return;
+      }
+      const [op, ref] = n;
+      if (op === "call" || op === "return_call" || op === "ref.func") markFunc(ref);
+      else if (op === "global.get" || op === "global.set") markGlobal(ref);
+      else if (op === "type") markType(ref);
+      else if (op === "call_indirect" || op === "return_call_indirect") {
+        for (const sub of n) if (typeof sub === "string" && sub[0] === "$") markTable(sub);
       }
-      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)) {
@@ -3068,117 +3082,130 @@ var treeshake = (ast) => {
       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);
+    if (kind === "func" || kind === "global" || kind === "type") {
+      if (nodeMap.get(node)?.used) result.push(node);
+    } else if (kind === "import") {
+      let used = false;
+      for (const sub of node) {
+        if (!Array.isArray(sub)) continue;
+        const e = nodeMap.get(sub);
+        if (e?.used) {
+          used = true;
+          break;
+        }
+      }
+      if (used) result.push(node);
     } else {
       result.push(node);
     }
   }
   return result;
 };
+var roundEven = (x) => x - Math.floor(x) !== 0.5 ? Math.round(x) : 2 * Math.round(x / 2);
+var i32c = (fn) => (a, b) => fn(a, b) ? 1 : 0;
+var u32c = (fn) => (a, b) => fn(a >>> 0, b >>> 0) ? 1 : 0;
+var i64c = (fn) => (a, b) => fn(a, b) ? 1 : 0;
+var u64c = (fn) => (a, b) => fn(BigInt.asUintN(64, a), BigInt.asUintN(64, b)) ? 1 : 0;
 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) => {
+  // i32 arithmetic
+  "i32.add": [(a, b) => a + b | 0, "i32"],
+  "i32.sub": [(a, b) => a - b | 0, "i32"],
+  "i32.mul": [(a, b) => Math.imul(a, b), "i32"],
+  "i32.div_s": [(a, b) => b !== 0 ? a / b | 0 : null, "i32"],
+  "i32.div_u": [(a, b) => b !== 0 ? (a >>> 0) / (b >>> 0) | 0 : null, "i32"],
+  "i32.rem_s": [(a, b) => b !== 0 ? a % b | 0 : null, "i32"],
+  "i32.rem_u": [(a, b) => b !== 0 ? (a >>> 0) % (b >>> 0) | 0 : null, "i32"],
+  "i32.and": [(a, b) => a & b, "i32"],
+  "i32.or": [(a, b) => a | b, "i32"],
+  "i32.xor": [(a, b) => a ^ b, "i32"],
+  "i32.shl": [(a, b) => a << (b & 31), "i32"],
+  "i32.shr_s": [(a, b) => a >> (b & 31), "i32"],
+  "i32.shr_u": [(a, b) => a >>> (b & 31), "i32"],
+  "i32.rotl": [(a, b) => {
     b &= 31;
     return a << b | a >>> 32 - b | 0;
-  },
-  "i32.rotr": (a, b) => {
+  }, "i32"],
+  "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) => {
+  }, "i32"],
+  "i32.eq": [i32c((a, b) => a === b), "i32"],
+  "i32.ne": [i32c((a, b) => a !== b), "i32"],
+  "i32.lt_s": [i32c((a, b) => a < b), "i32"],
+  "i32.lt_u": [u32c((a, b) => a < b), "i32"],
+  "i32.gt_s": [i32c((a, b) => a > b), "i32"],
+  "i32.gt_u": [u32c((a, b) => a > b), "i32"],
+  "i32.le_s": [i32c((a, b) => a <= b), "i32"],
+  "i32.le_u": [u32c((a, b) => a <= b), "i32"],
+  "i32.ge_s": [i32c((a, b) => a >= b), "i32"],
+  "i32.ge_u": [u32c((a, b) => a >= b), "i32"],
+  "i32.eqz": [(a) => a === 0 ? 1 : 0, "i32"],
+  "i32.clz": [(a) => Math.clz32(a), "i32"],
+  "i32.ctz": [(a) => a === 0 ? 32 : 31 - Math.clz32(a & -a), "i32"],
+  "i32.popcnt": [(a) => {
     let c = 0;
     while (a) {
       c += a & 1;
       a >>>= 1;
     }
     return c;
-  },
-  "i32.wrap_i64": (a) => Number(BigInt.asIntN(32, a)),
+  }, "i32"],
+  "i32.wrap_i64": [(a) => Number(BigInt.asIntN(32, a)), "i32"],
+  "i32.extend8_s": [(a) => a << 24 >> 24, "i32"],
+  "i32.extend16_s": [(a) => a << 16 >> 16, "i32"],
   // 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)
+  "i64.add": [(a, b) => BigInt.asIntN(64, a + b), "i64"],
+  "i64.sub": [(a, b) => BigInt.asIntN(64, a - b), "i64"],
+  "i64.mul": [(a, b) => BigInt.asIntN(64, a * b), "i64"],
+  "i64.div_s": [(a, b) => b !== 0n ? BigInt.asIntN(64, a / b) : null, "i64"],
+  "i64.div_u": [(a, b) => b !== 0n ? BigInt.asUintN(64, BigInt.asUintN(64, a) / BigInt.asUintN(64, b)) : null, "i64"],
+  "i64.rem_s": [(a, b) => b !== 0n ? BigInt.asIntN(64, a % b) : null, "i64"],
+  "i64.rem_u": [(a, b) => b !== 0n ? BigInt.asUintN(64, BigInt.asUintN(64, a) % BigInt.asUintN(64, b)) : null, "i64"],
+  "i64.and": [(a, b) => BigInt.asIntN(64, a & b), "i64"],
+  "i64.or": [(a, b) => BigInt.asIntN(64, a | b), "i64"],
+  "i64.xor": [(a, b) => BigInt.asIntN(64, a ^ b), "i64"],
+  "i64.shl": [(a, b) => BigInt.asIntN(64, a << (b & 63n)), "i64"],
+  "i64.shr_s": [(a, b) => BigInt.asIntN(64, a >> (b & 63n)), "i64"],
+  "i64.shr_u": [(a, b) => BigInt.asUintN(64, BigInt.asUintN(64, a) >> (b & 63n)), "i64"],
+  "i64.eq": [i64c((a, b) => a === b), "i32"],
+  "i64.ne": [i64c((a, b) => a !== b), "i32"],
+  "i64.lt_s": [i64c((a, b) => a < b), "i32"],
+  "i64.lt_u": [u64c((a, b) => a < b), "i32"],
+  "i64.gt_s": [i64c((a, b) => a > b), "i32"],
+  "i64.gt_u": [u64c((a, b) => a > b), "i32"],
+  "i64.le_s": [i64c((a, b) => a <= b), "i32"],
+  "i64.le_u": [u64c((a, b) => a <= b), "i32"],
+  "i64.ge_s": [i64c((a, b) => a >= b), "i32"],
+  "i64.ge_u": [u64c((a, b) => a >= b), "i32"],
+  "i64.eqz": [(a) => a === 0n ? 1 : 0, "i32"],
+  "i64.extend_i32_s": [(a) => BigInt(a), "i64"],
+  "i64.extend_i32_u": [(a) => BigInt(a >>> 0), "i64"],
+  "i64.extend8_s": [(a) => BigInt.asIntN(64, BigInt.asIntN(8, a)), "i64"],
+  "i64.extend16_s": [(a) => BigInt.asIntN(64, BigInt.asIntN(16, a)), "i64"],
+  "i64.extend32_s": [(a) => BigInt.asIntN(64, BigInt.asIntN(32, a)), "i64"],
+  // f32/f64 (NaN/precision-aware via Math.fround)
+  "f32.add": [(a, b) => Math.fround(a + b), "f32"],
+  "f32.sub": [(a, b) => Math.fround(a - b), "f32"],
+  "f32.mul": [(a, b) => Math.fround(a * b), "f32"],
+  "f32.div": [(a, b) => Math.fround(a / b), "f32"],
+  "f32.neg": [(a) => Math.fround(-a), "f32"],
+  "f32.abs": [(a) => Math.fround(Math.abs(a)), "f32"],
+  "f32.sqrt": [(a) => Math.fround(Math.sqrt(a)), "f32"],
+  "f32.ceil": [(a) => Math.fround(Math.ceil(a)), "f32"],
+  "f32.floor": [(a) => Math.fround(Math.floor(a)), "f32"],
+  "f32.trunc": [(a) => Math.fround(Math.trunc(a)), "f32"],
+  "f32.nearest": [(a) => Math.fround(roundEven(a)), "f32"],
+  "f64.add": [(a, b) => a + b, "f64"],
+  "f64.sub": [(a, b) => a - b, "f64"],
+  "f64.mul": [(a, b) => a * b, "f64"],
+  "f64.div": [(a, b) => a / b, "f64"],
+  "f64.neg": [(a) => -a, "f64"],
+  "f64.abs": [Math.abs, "f64"],
+  "f64.sqrt": [Math.sqrt, "f64"],
+  "f64.ceil": [Math.ceil, "f64"],
+  "f64.floor": [Math.floor, "f64"],
+  "f64.trunc": [Math.trunc, "f64"],
+  "f64.nearest": [roundEven, "f64"]
 };
 var getConst = (node) => {
   if (!Array.isArray(node) || node.length !== 2) return null;
@@ -3199,110 +3226,63 @@ var makeConst = (type, value) => {
 var fold = (ast) => {
   return walkPost2(clone2(ast), (node) => {
     if (!Array.isArray(node)) return;
-    const op = node[0];
-    const fn = FOLDABLE[op];
-    if (!fn) return;
+    const entry = FOLDABLE[node[0]];
+    if (!entry) return;
+    const [fn, t] = entry;
     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);
+      const r = fn(a.value);
+      if (r === null) return;
+      return makeConst(t, r);
     }
     if (fn.length === 2 && node.length === 3) {
-      const a = getConst(node[1]);
-      const b = getConst(node[2]);
+      const a = getConst(node[1]), 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);
+      const r = fn(a.value, b.value);
+      if (r === null) return;
+      return makeConst(t, r);
     }
   });
 };
+var commutativeIdentity = (neutral) => (a, b) => {
+  const ca = getConst(a), cb = getConst(b);
+  if (ca?.value === neutral) return b;
+  if (cb?.value === neutral) return a;
+  return null;
+};
+var rightIdentity = (neutral) => (a, b) => getConst(b)?.value === neutral ? a : null;
 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;
-  },
+  "i32.add": commutativeIdentity(0),
+  "i64.add": commutativeIdentity(0n),
   // x - 0 → x
-  "i32.sub": (a, b) => getConst(b)?.value === 0 ? a : null,
-  "i64.sub": (a, b) => getConst(b)?.value === 0n ? a : null,
+  "i32.sub": rightIdentity(0),
+  "i64.sub": rightIdentity(0n),
   // 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;
-  },
+  "i32.mul": commutativeIdentity(1),
+  "i64.mul": commutativeIdentity(1n),
   // 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,
+  "i32.div_s": rightIdentity(1),
+  "i32.div_u": rightIdentity(1),
+  "i64.div_s": rightIdentity(1n),
+  "i64.div_u": rightIdentity(1n),
   // 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;
-  },
+  "i32.and": commutativeIdentity(-1),
+  "i64.and": commutativeIdentity(-1n),
   // 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;
-  },
+  "i32.or": commutativeIdentity(0),
+  "i64.or": commutativeIdentity(0n),
   // 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;
-  },
+  "i32.xor": commutativeIdentity(0),
+  "i64.xor": commutativeIdentity(0n),
   // 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
+  "i32.shl": rightIdentity(0),
+  "i32.shr_s": rightIdentity(0),
+  "i32.shr_u": rightIdentity(0),
+  "i64.shl": rightIdentity(0n),
+  "i64.shr_s": rightIdentity(0n),
+  "i64.shr_u": rightIdentity(0n)
   // f + 0 → x (careful with -0.0, skip for floats)
   // f * 1 → x (careful with NaN, skip for floats)
 };
@@ -3377,41 +3357,15 @@ var branch = (ast) => {
     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 { cond, thenBranch, elseBranch } = parseIf(node);
       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"];
+      const taken = c.value !== 0 && c.value !== 0n ? thenBranch : elseBranch;
+      if (taken && taken.length > 1) {
+        const contents = taken.slice(1);
+        return contents.length === 1 ? contents[0] : ["block", ...contents];
       }
+      return ["nop"];
     }
     if (op === "br_if" && node.length >= 3) {
       const cond = node[node.length - 1];
@@ -3518,55 +3472,184 @@ var localReuse = (ast) => {
   });
   return result;
 };
+var IMPURE_OPS = /* @__PURE__ */ new Set([
+  "call",
+  "call_indirect",
+  "return_call",
+  "return_call_indirect",
+  "table.set",
+  "table.grow",
+  "table.fill",
+  "table.copy",
+  "table.init",
+  "struct.set",
+  "struct.new",
+  "array.set",
+  "array.new",
+  "array.new_fixed",
+  "array.new_data",
+  "array.new_elem",
+  "array.init_data",
+  "array.init_elem",
+  "ref.i31",
+  "global.set",
+  "local.set",
+  "local.tee",
+  "unreachable",
+  "return",
+  "br",
+  "br_if",
+  "br_table",
+  "br_on_null",
+  "br_on_non_null",
+  "br_on_cast",
+  "br_on_cast_fail",
+  "throw",
+  "rethrow",
+  "throw_ref",
+  "try_table",
+  "data.drop",
+  "elem.drop"
+]);
+var IMPURE_SUBSTRINGS = [".store", "memory.", ".atomic."];
+var isPure = (node) => {
+  if (!Array.isArray(node)) return true;
+  const op = node[0];
+  if (typeof op !== "string") return false;
+  if (IMPURE_OPS.has(op)) return false;
+  for (const sub of IMPURE_SUBSTRINGS) if (op.includes(sub)) return false;
+  for (let i = 1; i < node.length; i++) if (Array.isArray(node[i]) && !isPure(node[i])) return false;
+  return true;
+};
+var countLocalUses = (node) => {
+  const counts = /* @__PURE__ */ new Map();
+  const ensure = (name2) => {
+    if (!counts.has(name2)) counts.set(name2, { gets: 0, sets: 0, tees: 0 });
+    return counts.get(name2);
+  };
+  walk2(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;
+};
+var canSubst = (k) => getConst(k.val) || k.pure && k.singleUse;
+var substGets = (node, known) => walkPost2(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 clone2(k.val);
+});
+var forwardPropagate = (funcNode, params, useCounts) => {
+  let changed = false;
+  const getUseCount = (name2) => useCounts.get(name2) || { gets: 0, sets: 0, tees: 0 };
+  const known = /* @__PURE__ */ new Map();
+  for (let i = 1; i < funcNode.length; i++) {
+    const instr2 = funcNode[i];
+    if (!Array.isArray(instr2)) continue;
+    const op = instr2[0];
+    if (op === "param" || op === "result" || op === "local" || op === "type" || op === "export") continue;
+    if (op === "local.set" && instr2.length === 3 && typeof instr2[1] === "string") {
+      substGets(instr2[2], known);
+      const uses = getUseCount(instr2[1]);
+      known.set(instr2[1], {
+        val: instr2[2],
+        pure: isPure(instr2[2]),
+        singleUse: uses.gets <= 1 && uses.sets <= 1 && uses.tees === 0
+      });
+      continue;
+    }
+    if (op === "block" || op === "loop" || op === "if") known.clear();
+    if (op === "call" || op === "call_indirect" || op === "return_call" || op === "return_call_indirect") {
+      for (const [key, tracked] of known) if (!getConst(tracked.val)) known.delete(key);
+    }
+    if (op === "local.get" && instr2.length === 2 && typeof instr2[1] === "string") {
+      const tracked = known.get(instr2[1]);
+      if (tracked && canSubst(tracked)) {
+        const replacement = clone2(tracked.val);
+        instr2.length = 0;
+        instr2.push(...Array.isArray(replacement) ? replacement : [replacement]);
+        changed = true;
+        continue;
+      }
+    }
+    if (op !== "block" && op !== "loop" && op !== "if") {
+      const prev = clone2(instr2);
+      substGets(instr2, known);
+      if (!equal(prev, instr2)) changed = true;
+    }
+  }
+  return changed;
+};
+var eliminateSetGetPairs = (funcNode, params, useCounts) => {
+  let changed = false;
+  for (let i = 1; i < funcNode.length - 1; i++) {
+    const setNode = funcNode[i];
+    const getNode = funcNode[i + 1];
+    if (!Array.isArray(setNode) || setNode[0] !== "local.set" || setNode.length !== 3) continue;
+    if (!Array.isArray(getNode) || getNode[0] !== "local.get" || getNode.length !== 2) continue;
+    const name2 = setNode[1];
+    if (getNode[1] !== name2 || params.has(name2)) continue;
+    const uses = useCounts.get(name2) || { gets: 0, sets: 0, tees: 0 };
+    if (uses.sets !== 1 || uses.gets !== 1 || uses.tees !== 0) continue;
+    const expr2 = clone2(setNode[2]);
+    funcNode.splice(i, 2, ...Array.isArray(expr2) ? [expr2] : [expr2]);
+    changed = true;
+    i--;
+  }
+  return changed;
+};
+var createLocalTees = (funcNode, params, useCounts) => {
+  let changed = false;
+  for (let i = 1; i < funcNode.length - 1; i++) {
+    const setNode = funcNode[i];
+    const getNode = funcNode[i + 1];
+    if (!Array.isArray(setNode) || setNode[0] !== "local.set" || setNode.length !== 3) continue;
+    if (!Array.isArray(getNode) || getNode[0] !== "local.get" || getNode.length !== 2) continue;
+    const name2 = setNode[1];
+    if (getNode[1] !== name2 || params.has(name2)) continue;
+    const uses = useCounts.get(name2) || { gets: 0, sets: 0, tees: 0 };
+    if (uses.sets + uses.gets + uses.tees <= 2) continue;
+    funcNode.splice(i, 2, ["local.tee", name2, clone2(setNode[2])]);
+    changed = true;
+  }
+  return changed;
+};
+var eliminateDeadStores = (funcNode, params, useCounts) => {
+  let changed = false;
+  const getPostUseCount = (name2) => useCounts.get(name2) || { 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 name2 = typeof sub[1] === "string" ? sub[1] : null;
+    if (!name2 || params.has(name2)) continue;
+    const uses = getPostUseCount(name2);
+    if (sub[0] === "local.set" && uses.gets === 0 && uses.tees === 0 && isPure(sub[2])) {
+      funcNode.splice(i, 1);
+      changed = true;
+    } else if (sub[0] === "local" && name2[0] === "$" && uses.gets === 0 && uses.sets === 0 && uses.tees === 0) {
+      funcNode.splice(i, 1);
+      changed = true;
+    }
+  }
+  return changed;
+};
 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);
+  walk2(result, (funcNode) => {
+    if (!Array.isArray(funcNode) || funcNode[0] !== "func") return;
+    const params = /* @__PURE__ */ new Set();
+    for (const sub of funcNode)
+      if (Array.isArray(sub) && sub[0] === "param" && typeof sub[1] === "string") params.add(sub[1]);
+    for (let pass = 0; pass < 4; pass++) {
+      let changed = false;
+      if (forwardPropagate(funcNode, params, countLocalUses(funcNode))) changed = true;
+      if (eliminateSetGetPairs(funcNode, params, countLocalUses(funcNode))) changed = true;
+      if (createLocalTees(funcNode, params, countLocalUses(funcNode))) changed = true;
+      if (eliminateDeadStores(funcNode, params, countLocalUses(funcNode))) changed = true;
+      if (!changed) break;
+    }
   });
   return result;
 };
@@ -3600,7 +3683,7 @@ var inline = (ast) => {
         body.push(sub);
       }
     }
-    if (params && !hasLocals && !hasExport && params.length <= 2 && body.length === 1) {
+    if (params && !hasLocals && !hasExport && params.length <= 4 && body.length === 1) {
       const paramNames = new Set(params.map((p) => p.name));
       let mutatesParam = false;
       walk2(body[0], (n) => {
@@ -3637,19 +3720,702 @@ var inline = (ast) => {
   });
   return result;
 };
+var vacuum = (ast) => {
+  return walkPost2(clone2(ast), (node) => {
+    if (!Array.isArray(node)) return;
+    const op = node[0];
+    if (op === "nop") return ["nop"];
+    if (op === "drop" && node.length === 2 && isPure(node[1])) {
+      return ["nop"];
+    }
+    if (op === "select" && node.length >= 4 && equal(node[1], node[2])) return node[1];
+    if (op === "if") {
+      const { cond, thenBranch, elseBranch } = parseIf(node);
+      const thenEmpty = !thenBranch || thenBranch.length <= 1;
+      const elseEmpty = !elseBranch || elseBranch.length <= 1;
+      if (thenEmpty && elseEmpty) return isPure(cond) ? ["nop"] : ["drop", cond];
+      if (elseBranch && elseEmpty && !thenEmpty) {
+        return node.filter((c) => c !== elseBranch);
+      }
+    }
+    if (op === "func" || op === "block" || op === "loop" || op === "then" || op === "else") {
+      const cleaned = [op];
+      for (let i = 1; i < node.length; i++) {
+        const child = node[i];
+        if (child === "nop" || Array.isArray(child) && child[0] === "nop") continue;
+        const next = node[i + 1];
+        const isDrop = next === "drop" || Array.isArray(next) && next[0] === "drop" && next.length === 1;
+        if (Array.isArray(child) && isPure(child) && isDrop) {
+          i++;
+          continue;
+        }
+        cleaned.push(child);
+      }
+      if (cleaned.length !== node.length) return cleaned;
+    }
+  });
+};
+var PEEPHOLE = {
+  // Self-cancelling / tautological binary ops
+  "i32.sub": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i64.sub": (a, b) => equal(a, b) ? ["i64.const", 0n] : null,
+  "i32.xor": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i64.xor": (a, b) => equal(a, b) ? ["i64.const", 0n] : null,
+  "i32.and": (a, b) => equal(a, b) ? a : null,
+  "i64.and": (a, b) => equal(a, b) ? a : null,
+  "i32.or": (a, b) => equal(a, b) ? a : null,
+  "i64.or": (a, b) => equal(a, b) ? a : null,
+  "i32.eq": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
+  "i64.eq": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
+  "i32.ne": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i64.ne": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i32.lt_s": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i32.lt_u": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i32.gt_s": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i32.gt_u": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i32.le_s": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
+  "i32.le_u": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
+  "i32.ge_s": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
+  "i32.ge_u": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
+  "i64.lt_s": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i64.lt_u": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i64.gt_s": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i64.gt_u": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
+  "i64.le_s": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
+  "i64.le_u": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
+  "i64.ge_s": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
+  "i64.ge_u": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
+  // Zero/all-bits absorption
+  "i32.mul": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 0 || cb?.value === 0) return ["i32.const", 0];
+    return null;
+  },
+  "i64.mul": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 0n || cb?.value === 0n) return ["i64.const", 0n];
+    return null;
+  },
+  "i32.and": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 0 || cb?.value === 0) return ["i32.const", 0];
+    return null;
+  },
+  "i64.and": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === 0n || cb?.value === 0n) return ["i64.const", 0n];
+    return null;
+  },
+  "i32.or": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === -1 || cb?.value === -1) return ["i32.const", -1];
+    return null;
+  },
+  "i64.or": (a, b) => {
+    const ca = getConst(a), cb = getConst(b);
+    if (ca?.value === -1n || cb?.value === -1n) return ["i64.const", -1n];
+    return null;
+  },
+  // (local.set $x (local.get $x)) → nop
+  "local.set": (a, b) => Array.isArray(b) && b[0] === "local.get" && b[1] === a ? ["nop"] : null
+};
+var peephole = (ast) => {
+  return walkPost2(clone2(ast), (node) => {
+    if (!Array.isArray(node) || node.length !== 3) return;
+    const fn = PEEPHOLE[node[0]];
+    if (!fn) return;
+    const result = fn(node[1], node[2]);
+    if (result !== null) return result;
+  });
+};
+var globals = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  const result = clone2(ast);
+  const constGlobals = /* @__PURE__ */ new Map();
+  const mutableGlobals = /* @__PURE__ */ new Set();
+  for (const node of result.slice(1)) {
+    if (!Array.isArray(node) || node[0] !== "global") continue;
+    const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
+    if (!name2) continue;
+    const hasName = typeof node[1] === "string" && node[1][0] === "$";
+    const initIdx = hasName ? 3 : 2;
+    const typeSlot = hasName ? node[2] : node[1];
+    if (Array.isArray(typeSlot) && typeSlot[0] === "mut") continue;
+    const init = node[initIdx];
+    if (getConst(init)) constGlobals.set(name2, init);
+  }
+  walk2(result, (n) => {
+    if (!Array.isArray(n) || n[0] !== "global.set") return;
+    const ref = n[1];
+    if (typeof ref === "string" && ref[0] === "$") mutableGlobals.add(ref);
+  });
+  for (const name2 of mutableGlobals) constGlobals.delete(name2);
+  if (constGlobals.size === 0) return result;
+  return walkPost2(result, (node) => {
+    if (!Array.isArray(node) || node[0] !== "global.get" || node.length !== 2) return;
+    const ref = node[1];
+    if (constGlobals.has(ref)) return clone2(constGlobals.get(ref));
+  });
+};
+var offset = (ast) => {
+  return walkPost2(clone2(ast), (node) => {
+    if (!Array.isArray(node)) return;
+    const op = node[0];
+    if (typeof op !== "string" || !op.endsWith("load") && !op.endsWith("store")) return;
+    const isStore = op.endsWith("store");
+    let currentOffset = 0;
+    let memIdx = null;
+    let argStart = 1;
+    if (typeof node[1] === "string" && (node[1][0] === "$" || !isNaN(node[1]))) {
+      memIdx = node[1];
+      argStart = 2;
+    }
+    while (argStart < node.length && typeof node[argStart] === "string" && (node[argStart].startsWith("offset=") || node[argStart].startsWith("align="))) {
+      if (node[argStart].startsWith("offset=")) {
+        currentOffset = +node[argStart].slice(7);
+      }
+      argStart++;
+    }
+    const ptrIdx = isStore ? node.length - 2 : node.length - 1;
+    const valIdx = isStore ? node.length - 1 : -1;
+    if (ptrIdx < argStart) return;
+    const ptr = node[ptrIdx];
+    if (!Array.isArray(ptr) || ptr[0] !== "i32.add" || ptr.length !== 3) return;
+    const a = ptr[1], b = ptr[2];
+    const ca = getConst(a), cb = getConst(b);
+    let base = null, addend = null;
+    if (ca && ca.type === "i32") {
+      addend = ca.value;
+      base = b;
+    } else if (cb && cb.type === "i32") {
+      addend = cb.value;
+      base = a;
+    }
+    if (base === null || addend === null) return;
+    const newOffset = currentOffset + addend;
+    const newNode = [op];
+    if (memIdx !== null) newNode.push(memIdx);
+    newNode.push(`offset=${newOffset}`);
+    let alignParam = null;
+    for (let i = argStart; i < ptrIdx; i++) {
+      if (typeof node[i] === "string" && node[i].startsWith("align=")) {
+        alignParam = node[i];
+      }
+    }
+    if (alignParam) newNode.push(alignParam);
+    newNode.push(base);
+    if (isStore) newNode.push(node[valIdx]);
+    return newNode;
+  });
+};
+var unbranch = (ast) => {
+  const result = clone2(ast);
+  walk2(result, (node) => {
+    if (!Array.isArray(node)) return;
+    const op = node[0];
+    if (op !== "block" && op !== "loop") return;
+    let labelIdx = 1;
+    let label = null;
+    if (typeof node[1] === "string" && node[1][0] === "$") {
+      label = node[1];
+      labelIdx = 2;
+    }
+    if (!label) return;
+    let lastIdx = -1;
+    for (let i = node.length - 1; i >= labelIdx; i--) {
+      const child = node[i];
+      if (!Array.isArray(child)) {
+        if (child !== "nop" && child !== "end") lastIdx = i;
+        continue;
+      }
+      const cop = child[0];
+      if (cop === "param" || cop === "result" || cop === "local" || cop === "type" || cop === "export") continue;
+      lastIdx = i;
+      break;
+    }
+    if (lastIdx < 0) return;
+    const last = node[lastIdx];
+    if (Array.isArray(last) && last[0] === "br" && last[1] === label) {
+      node.splice(lastIdx, 1);
+    }
+  });
+  return result;
+};
+var stripmut = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  const result = clone2(ast);
+  const written = /* @__PURE__ */ new Set();
+  walk2(result, (n) => {
+    if (Array.isArray(n) && n[0] === "global.set" && typeof n[1] === "string") written.add(n[1]);
+  });
+  return walkPost2(result, (node) => {
+    if (!Array.isArray(node) || node[0] !== "global") return;
+    const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
+    if (!name2 || written.has(name2)) return;
+    const hasName = typeof node[1] === "string" && node[1][0] === "$";
+    const typeSlot = hasName ? node[2] : node[1];
+    if (Array.isArray(typeSlot) && typeSlot[0] === "mut") {
+      const newNode = [...node];
+      newNode[hasName ? 2 : 1] = typeSlot[1];
+      return newNode;
+    }
+  });
+};
+var brif = (ast) => {
+  return walkPost2(clone2(ast), (node) => {
+    if (!Array.isArray(node) || node[0] !== "if") return;
+    const { cond, thenBranch, elseBranch } = parseIf(node);
+    const thenEmpty = !thenBranch || thenBranch.length <= 1;
+    const elseEmpty = !elseBranch || elseBranch.length <= 1;
+    if (!thenEmpty && elseEmpty && thenBranch.length === 2) {
+      const t = thenBranch[1];
+      if (Array.isArray(t) && t[0] === "br" && t.length === 2) return ["br_if", t[1], cond];
+    }
+    if (thenEmpty && !elseEmpty && elseBranch.length === 2) {
+      const e = elseBranch[1];
+      if (Array.isArray(e) && e[0] === "br" && e.length === 2) return ["br_if", e[1], ["i32.eqz", cond]];
+    }
+  });
+};
+var foldarms = (ast) => {
+  return walkPost2(clone2(ast), (node) => {
+    if (!Array.isArray(node) || node[0] !== "if") return;
+    const { thenBranch, elseBranch } = parseIf(node);
+    if (!thenBranch || !elseBranch) return;
+    if (thenBranch.length <= 1 || elseBranch.length <= 1) return;
+    let common = 0;
+    const minLen = Math.min(thenBranch.length, elseBranch.length);
+    for (let i = 1; i < minLen; i++) {
+      if (!equal(thenBranch[thenBranch.length - i], elseBranch[elseBranch.length - i])) break;
+      common++;
+    }
+    if (common === 0) return;
+    const hoisted = thenBranch.slice(thenBranch.length - common);
+    const newThen = thenBranch.slice(0, thenBranch.length - common);
+    const newElse = elseBranch.slice(0, elseBranch.length - common);
+    const block = ["block"];
+    for (let i = 1; i < node.length; i++) {
+      const c = node[i];
+      if (Array.isArray(c) && (c[0] === "then" || c[0] === "else")) break;
+      if (Array.isArray(c) && (c[0] === "result" || c[0] === "type")) block.push(c);
+    }
+    const newIf = ["if"];
+    for (let i = 1; i < node.length; i++) {
+      const c = node[i];
+      if (Array.isArray(c) && (c[0] === "then" || c[0] === "else")) break;
+      newIf.push(c);
+    }
+    newIf.push(newThen.length > 1 ? newThen : ["then"]);
+    newIf.push(newElse.length > 1 ? newElse : ["else"]);
+    block.push(newIf, ...hoisted);
+    return block;
+  });
+};
+var hashFunc = (node, localNames) => {
+  const parts = [];
+  const stack = [node];
+  while (stack.length) {
+    const v = stack.pop();
+    if (Array.isArray(v)) {
+      stack.push("|");
+      for (let i = v.length - 1; i >= 0; i--) stack.push(v[i]);
+      stack.push("[");
+    } else if (typeof v === "string") {
+      parts.push(localNames.has(v) ? "$__L" : v);
+    } else if (typeof v === "bigint") {
+      parts.push(v.toString() + "n");
+    } else if (typeof v === "number") {
+      parts.push(v.toString());
+    } else if (v === null) {
+      parts.push("null");
+    } else if (v === true) {
+      parts.push("t");
+    } else if (v === false) {
+      parts.push("f");
+    } else {
+      parts.push(String(v));
+    }
+  }
+  return parts.join(",");
+};
+var dedupe = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  const result = clone2(ast);
+  const signatures = /* @__PURE__ */ new Map();
+  const redirects = /* @__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;
+    const localNames = /* @__PURE__ */ new Set();
+    if (typeof node[1] === "string" && node[1][0] === "$") localNames.add(node[1]);
+    walk2(node, (n) => {
+      if (!Array.isArray(n) || typeof n[1] !== "string" || n[1][0] !== "$") return;
+      const op = n[0];
+      if (op === "param" || op === "local" || op === "block" || op === "loop" || op === "if") {
+        localNames.add(n[1]);
+      }
+    });
+    const hash = hashFunc(node, localNames);
+    if (signatures.has(hash)) {
+      redirects.set(name2, signatures.get(hash));
+    } else {
+      signatures.set(hash, name2);
+    }
+  }
+  if (redirects.size === 0) return result;
+  walkPost2(result, (node) => {
+    if (!Array.isArray(node)) return;
+    const op = node[0];
+    if ((op === "call" || op === "return_call") && redirects.has(node[1])) {
+      return [op, redirects.get(node[1]), ...node.slice(2)];
+    }
+    if (op === "ref.func" && redirects.has(node[1])) {
+      return ["ref.func", redirects.get(node[1])];
+    }
+    if (op === "elem") {
+      const funcs = node[node.length - 1];
+      if (Array.isArray(funcs)) {
+        return [...node.slice(0, -1), funcs.map((f) => redirects.get(f) || f)];
+      }
+    }
+    if (op === "call_indirect" && node.length >= 3) {
+      const typeRef = node[1];
+      if (typeof typeRef === "string" && redirects.has(typeRef)) {
+        return ["call_indirect", redirects.get(typeRef), ...node.slice(2)];
+      }
+    }
+  });
+  return result;
+};
+var dedupTypes = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  const result = clone2(ast);
+  const signatures = /* @__PURE__ */ new Map();
+  const redirects = /* @__PURE__ */ new Map();
+  for (const node of result.slice(1)) {
+    if (!Array.isArray(node) || node[0] !== "type") continue;
+    const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
+    if (!name2) continue;
+    const hash = hashFunc(node, /* @__PURE__ */ new Set([name2]));
+    if (signatures.has(hash)) {
+      redirects.set(name2, signatures.get(hash));
+    } else {
+      signatures.set(hash, name2);
+    }
+  }
+  if (redirects.size === 0) return result;
+  for (let i = result.length - 1; i >= 0; i--) {
+    const node = result[i];
+    if (Array.isArray(node) && node[0] === "type") {
+      const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
+      if (name2 && redirects.has(name2)) result.splice(i, 1);
+    }
+  }
+  walkPost2(result, (node) => {
+    if (!Array.isArray(node)) return;
+    const op = node[0];
+    if (op === "func") {
+      for (let i = 1; i < node.length; i++) {
+        const sub = node[i];
+        if (Array.isArray(sub) && sub[0] === "type" && typeof sub[1] === "string" && redirects.has(sub[1])) {
+          node[i] = ["type", redirects.get(sub[1])];
+        }
+      }
+    }
+    if (op === "import") {
+      for (let i = 1; i < node.length; i++) {
+        const sub = node[i];
+        if (Array.isArray(sub)) {
+          for (let j = 1; j < sub.length; j++) {
+            const inner = sub[j];
+            if (Array.isArray(inner) && inner[0] === "type" && typeof inner[1] === "string" && redirects.has(inner[1])) {
+              sub[j] = ["type", redirects.get(inner[1])];
+            }
+          }
+        }
+      }
+    }
+    if (op === "call_indirect" || op === "return_call_indirect") {
+      if (typeof node[1] === "string" && redirects.has(node[1])) {
+        return [op, redirects.get(node[1]), ...node.slice(2)];
+      }
+      if (Array.isArray(node[1]) && node[1][0] === "type" && typeof node[1][1] === "string" && redirects.has(node[1][1])) {
+        return [op, ["type", redirects.get(node[1][1])], ...node.slice(2)];
+      }
+    }
+  });
+  return result;
+};
+var parseDataString = (str2) => {
+  if (typeof str2 !== "string" || str2.length < 2 || str2[0] !== '"') return new Uint8Array();
+  const inner = str2.slice(1, -1);
+  const bytes = [];
+  for (let i = 0; i < inner.length; i++) {
+    if (inner[i] === "\\") {
+      const next = inner[++i];
+      if (next === "x" || next === "X") {
+        bytes.push(parseInt(inner.slice(i + 1, i + 3), 16));
+        i += 2;
+      } else if (/[0-9a-fA-F]/.test(next) && /[0-9a-fA-F]/.test(inner[i + 1])) {
+        bytes.push(parseInt(inner.slice(i, i + 2), 16));
+        i++;
+      } else if (next === "n") bytes.push(10);
+      else if (next === "t") bytes.push(9);
+      else if (next === "r") bytes.push(13);
+      else if (next === "\\") bytes.push(92);
+      else if (next === '"') bytes.push(34);
+      else bytes.push(next.charCodeAt(0));
+    } else {
+      bytes.push(inner.charCodeAt(i));
+    }
+  }
+  return new Uint8Array(bytes);
+};
+var encodeDataString = (bytes) => {
+  let str2 = '"';
+  for (let i = 0; i < bytes.length; i++) {
+    const b = bytes[i];
+    if (b >= 32 && b < 127 && b !== 34 && b !== 92) {
+      str2 += String.fromCharCode(b);
+    } else {
+      str2 += "\\" + b.toString(16).padStart(2, "0");
+    }
+  }
+  return str2 + '"';
+};
+var trimTrailingZeros = (items) => {
+  const bytes = [];
+  for (const item of items) {
+    if (typeof item === "string") {
+      bytes.push(...parseDataString(item));
+    } else if (Array.isArray(item) && item[0] === "i8") {
+      for (let i = 1; i < item.length; i++) bytes.push(Number(item[i]) & 255);
+    } else {
+      return items;
+    }
+  }
+  let end = bytes.length;
+  while (end > 0 && bytes[end - 1] === 0) end--;
+  if (end === bytes.length) return items;
+  if (end === 0) return [];
+  return [encodeDataString(new Uint8Array(bytes.slice(0, end)))];
+};
+var getDataOffset = (node) => {
+  let idx = 1;
+  if (typeof node[idx] === "string" && node[idx][0] === "$") idx++;
+  if (Array.isArray(node[idx]) && node[idx][0] === "memory") {
+    const mem = node[idx][1];
+    idx++;
+    const off2 = node[idx];
+    if (Array.isArray(off2) && (off2[0] === "i32.const" || off2[0] === "i64.const")) {
+      return { memidx: mem, offset: Number(off2[1]) };
+    }
+    return null;
+  }
+  const off = node[idx];
+  if (Array.isArray(off) && (off[0] === "i32.const" || off[0] === "i64.const")) {
+    return { memidx: 0, offset: Number(off[1]) };
+  }
+  return null;
+};
+var getDataLength = (node) => {
+  let idx = 1;
+  if (typeof node[idx] === "string" && node[idx][0] === "$") idx++;
+  if (Array.isArray(node[idx]) && node[idx][0] === "memory") idx++;
+  if (Array.isArray(node[idx]) && typeof node[idx][0] === "string" && !node[idx][0].startsWith('"')) idx++;
+  let len = 0;
+  for (let i = idx; i < node.length; i++) {
+    const item = node[i];
+    if (typeof item === "string") len += parseDataString(item).length;
+    else if (Array.isArray(item) && item[0] === "i8") len += item.length - 1;
+    else return null;
+  }
+  return len;
+};
+var mergeDataSegments = (a, b) => {
+  let aIdx = 1;
+  if (typeof a[aIdx] === "string" && a[aIdx][0] === "$") aIdx++;
+  if (Array.isArray(a[aIdx]) && a[aIdx][0] === "memory") aIdx++;
+  if (Array.isArray(a[aIdx]) && typeof a[aIdx][0] === "string" && !a[aIdx][0].startsWith('"')) aIdx++;
+  let bIdx = 1;
+  if (typeof b[bIdx] === "string" && b[bIdx][0] === "$") bIdx++;
+  if (Array.isArray(b[bIdx]) && b[bIdx][0] === "memory") bIdx++;
+  if (Array.isArray(b[bIdx]) && typeof b[bIdx][0] === "string" && !b[bIdx][0].startsWith('"')) bIdx++;
+  const aContent = a.slice(aIdx);
+  const bContent = b.slice(bIdx);
+  if (aContent.length === 1 && bContent.length === 1 && typeof aContent[0] === "string" && typeof bContent[0] === "string") {
+    const aBytes = parseDataString(aContent[0]);
+    const bBytes = parseDataString(bContent[0]);
+    const merged = new Uint8Array(aBytes.length + bBytes.length);
+    merged.set(aBytes);
+    merged.set(bBytes, aBytes.length);
+    a.length = aIdx;
+    a.push(encodeDataString(merged));
+    return true;
+  }
+  a.length = aIdx;
+  a.push(...aContent, ...bContent);
+  return true;
+};
+var packData = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  let result = clone2(ast);
+  for (const node of result) {
+    if (!Array.isArray(node) || node[0] !== "data") continue;
+    let contentStart = 1;
+    if (typeof node[1] === "string" && node[1][0] === "$") contentStart = 2;
+    if (contentStart < node.length && Array.isArray(node[contentStart]) && typeof node[contentStart][0] === "string" && !node[contentStart][0].startsWith('"')) {
+      contentStart++;
+    }
+    const content = node.slice(contentStart);
+    if (content.length === 0) continue;
+    const trimmed = trimTrailingZeros(content);
+    if (trimmed.length !== content.length || trimmed.length > 0 && trimmed[0] !== content[0]) {
+      node.length = contentStart;
+      node.push(...trimmed);
+    }
+  }
+  const dataNodes = [];
+  for (let i = 0; i < result.length; i++) {
+    const node = result[i];
+    if (Array.isArray(node) && node[0] === "data") {
+      const info = getDataOffset(node);
+      if (info) {
+        const len = getDataLength(node);
+        if (len !== null) dataNodes.push({ ...info, node, index: i, len });
+      }
+    }
+  }
+  dataNodes.sort((a, b) => {
+    const ma = String(a.memidx), mb = String(b.memidx);
+    if (ma !== mb) return ma.localeCompare(mb);
+    return a.offset - b.offset;
+  });
+  const toRemove = /* @__PURE__ */ new Set();
+  for (let i = 0; i < dataNodes.length - 1; i++) {
+    const a = dataNodes[i];
+    const b = dataNodes[i + 1];
+    if (toRemove.has(a.index) || String(a.memidx) !== String(b.memidx)) continue;
+    if (a.offset + a.len !== b.offset) continue;
+    if (mergeDataSegments(a.node, b.node)) {
+      toRemove.add(b.index);
+      a.len = getDataLength(a.node);
+    }
+  }
+  if (toRemove.size > 0) {
+    result = result.filter((_, i) => !toRemove.has(i));
+  }
+  return result;
+};
+var makeShortener = () => {
+  const map = /* @__PURE__ */ new Map();
+  let n = 0;
+  return (name2) => {
+    if (!map.has(name2)) {
+      let id2 = "", x = n++;
+      do {
+        id2 = String.fromCharCode(97 + x % 26) + id2;
+        x = Math.floor(x / 26) - 1;
+      } while (x >= 0);
+      map.set(name2, id2 || "a");
+    }
+    return map.get(name2);
+  };
+};
+var minifyImports = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  const result = clone2(ast);
+  const shortMod = makeShortener();
+  const shortField = makeShortener();
+  for (const node of result) {
+    if (!Array.isArray(node) || node[0] !== "import") continue;
+    if (typeof node[1] === "string" && node[1][0] === '"') {
+      node[1] = '"' + shortMod(node[1].slice(1, -1)) + '"';
+    }
+    if (typeof node[2] === "string" && node[2][0] === '"') {
+      node[2] = '"' + shortField(node[2].slice(1, -1)) + '"';
+    }
+  }
+  return result;
+};
+var reorderSafe = (ast) => {
+  let safe = true;
+  walk2(ast, (n) => {
+    if (!safe || !Array.isArray(n)) return;
+    const op = n[0];
+    if (op === "func" && (typeof n[1] !== "string" || n[1][0] !== "$")) safe = false;
+    else if ((op === "call" || op === "return_call" || op === "ref.func") && (typeof n[1] !== "string" || n[1][0] !== "$")) safe = false;
+    else if (op === "start" && (typeof n[1] !== "string" || n[1][0] !== "$")) safe = false;
+    else if (op === "elem") {
+      for (const sub of n) {
+        if (typeof sub === "string" && sub[0] !== "$" && /^\d/.test(sub)) {
+          safe = false;
+          break;
+        }
+        if (Array.isArray(sub) && sub[0] === "ref.func" && (typeof sub[1] !== "string" || sub[1][0] !== "$")) {
+          safe = false;
+          break;
+        }
+      }
+    }
+  });
+  return safe;
+};
+var reorder = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  if (!reorderSafe(ast)) return ast;
+  const result = clone2(ast);
+  const callCounts = /* @__PURE__ */ new Map();
+  walk2(result, (n) => {
+    if (!Array.isArray(n)) return;
+    if (n[0] === "call" || n[0] === "return_call") {
+      callCounts.set(n[1], (callCounts.get(n[1]) || 0) + 1);
+    }
+  });
+  const imports = [], funcs = [], others = [];
+  for (const node of result.slice(1)) {
+    if (!Array.isArray(node)) {
+      others.push(node);
+      continue;
+    }
+    if (node[0] === "import") imports.push(node);
+    else if (node[0] === "func") funcs.push(node);
+    else others.push(node);
+  }
+  funcs.sort((a, b) => (callCounts.get(b[1]) || 0) - (callCounts.get(a[1]) || 0));
+  return ["module", ...imports, ...funcs, ...others];
+};
 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);
+  for (let round = 0; round < 6; round++) {
+    const before = ast;
+    if (opts.stripmut) ast = stripmut(ast);
+    if (opts.globals) ast = globals(ast);
+    if (opts.fold) ast = fold(ast);
+    if (opts.identity) ast = identity(ast);
+    if (opts.peephole) ast = peephole(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.offset) ast = offset(ast);
+    if (opts.unbranch) ast = unbranch(ast);
+    if (opts.brif) ast = brif(ast);
+    if (opts.foldarms) ast = foldarms(ast);
+    if (opts.deadcode) ast = deadcode(ast);
+    if (opts.vacuum) ast = vacuum(ast);
+    if (opts.locals) ast = localReuse(ast);
+    if (opts.dedupe) ast = dedupe(ast);
+    if (opts.dedupTypes) ast = dedupTypes(ast);
+    if (opts.packData) ast = packData(ast);
+    if (opts.reorder) ast = reorder(ast);
+    if (opts.treeshake) ast = treeshake(ast);
+    if (opts.minifyImports) ast = minifyImports(ast);
+    if (equal(before, ast)) break;
+  }
   return ast;
 }
 
@@ -3717,7 +4483,7 @@ function genImports(imports) {
 }
 function compile2(source, ...values) {
   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();
   }
   if (Array.isArray(source) && source.raw) {
@@ -3742,7 +4508,7 @@ function compile2(source, ...values) {
           }
           return parsed;
         }
-        if (value instanceof Uint8Array) return [...value];
+        if (value.byteLength !== void 0) return [...value];
         return value;
       }
       return node;