watr 5.0.0 → 5.1.1

package/src/print.js

@@ -28,7 +28,10 @@ export default function print(tree, options = {}) {
     .join(newline)
 
   function isComment(node) {
-    return typeof node === 'string' && node[1] === ';'
+    // node[1]===';' alone also matches a plain string starting with ';' (n[0] is
+    // always '"' for a real string token, so n[1] is its first content byte) — a
+    // block comment is '(;…', so also require n[0]==='(' to disambiguate.
+    return typeof node === 'string' && (node[0] === ';' || (node[0] === '(' && node[1] === ';'))
   }
 
   function printNode(node, level = 0) {
@@ -60,8 +63,10 @@ export default function print(tree, options = {}) {
     for (let i = 1; i < node.length; i++) {
       const sub = node[i]?.valueOf?.() ?? node[i] // "\00abc\ff" strings are stored as arrays but have ._ with original value
 
-      // comments - skip if not enabled
-      if (typeof sub === 'string' && sub[1] === ';') {
+      // comments - skip if not enabled. sub[1]===';' alone would also match a plain
+      // string starting with ';' (n[0] is always '"' for a real string; block comments
+      // are '(;…', so n[0]==='(' must hold too) — see isComment above.
+      if (typeof sub === 'string' && (sub[0] === ';' || (sub[0] === '(' && sub[1] === ';'))) {
         if (!comments) continue
         // line comments (;;) - MUST end with newline to avoid consuming following elements
         if (sub[0] === ';') {

package/src/util.js

@@ -1,23 +1,37 @@
+// Ambient source/position for err()'s "at line:col" suffix — set by assemble()
+// as it walks a module (err.loc/err.src used to be expando properties on the
+// `err` function itself; a self-hosted compile-clear-compile loop bump-allocates
+// a HASH props table the first time a property lands on a function value, and
+// that table dangles across an arena `_clear` between compiles — corrupting the
+// SECOND self-host compile. Plain module-level `let`s are a global-set, not a
+// dynamic-key write, so they carry no such table and are `_clear`-safe.
+let errLoc, errSrc
+
 /**
  * Throws an error with optional source position.
- * Uses err.src for source and err.loc for default position.
- * If pos provided or err.loc set, appends "at line:col".
+ * Uses the ambient errSrc for source and errLoc for default position.
+ * If pos provided or errLoc set, appends "at line:col".
  *
  * @param {string} text - Error message
- * @param {number} [pos] - Byte offset in source (defaults to err.loc)
+ * @param {number} [pos] - Byte offset in source (defaults to errLoc)
  * @throws {Error}
  */
-export const err = (text, pos=err.loc) => {
-  if (pos != null && err.src) {
+export const err = (text, pos=errLoc) => {
+  if (pos != null && errSrc) {
     let line = 1, col = 1
-    for (let i = 0; i < pos && i < err.src.length; i++) {
-      if (err.src[i] === '\n') line++, col = 1
+    for (let i = 0; i < pos && i < errSrc.length; i++) {
+      if (errSrc.charCodeAt(i) === 10) line++, col = 1
       else col++
     }
     text += ` at ${line}:${col}`
   }
   throw Error(text)
 }
+// Accessors for the ambient position/source (compile.js is the only writer).
+export const setErrLoc = (loc) => { errLoc = loc }
+export const setErrSrc = (src) => { errSrc = src }
+export const getErrLoc = () => errLoc
+export const getErrSrc = () => errSrc
 
 /** Regex to detect invalid underscore placement in numbers */
 export const sepRE = /^_|_$|[^\da-f]_|_[^\da-f]/i
@@ -97,7 +111,13 @@ export const clone = (node) => Array.isArray(node) ? node.map(clone) : node
  */
 export const walk = (node, fn, parent, idx) => {
   fn(node, parent, idx)
-  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) walk(node[i], fn, node, i)
+  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) {
+    const c = node[i]
+    // leaves get their visit inline — half of all nodes are strings/numbers, and a
+    // full recursive frame per leaf dominates traversal cost on big modules
+    if (Array.isArray(c)) walk(c, fn, node, i)
+    else fn(c, node, i)
+  }
 }
 
 /**
@@ -115,7 +135,11 @@ export const walk = (node, fn, parent, idx) => {
  * @returns {any} The (possibly replaced) node
  */
 export const walkPost = (node, fn, parent, idx) => {
-  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) walkPost(node[i], fn, node, i)
+  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) {
+    const c = node[i]
+    if (Array.isArray(c)) walkPost(c, fn, node, i)
+    else { const r = fn(c, node, i); if (r !== undefined) node[i] = r }
+  }
   const result = fn(node, parent, idx)
   if (result !== undefined && parent) parent[idx] = result
   return result !== undefined ? result : node

package/types/src/compile.d.ts

@@ -10,4 +10,5 @@ export default function compile(nodes: any): any;
  * summed from section sizes instead of building them (invariant-tested).
  */
 export function size(nodes: any): any;
+export function numdata(item: any): any[];
 //# sourceMappingURL=compile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AA4UA;;;;GAIG;AACH,iDAAiE;AAEjE;;;;GAIG;AACH,sCAA4D"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AA8VA;;;;GAIG;AACH,iDAAiE;AAEjE;;;;GAIG;AACH,sCAA4D;AAg8BrD,0CAcN"}

package/types/src/const.d.ts

@@ -1,4 +1,5 @@
-export const INSTR: (string | string[])[];
+export const OPCODE: {};
+export const IMM: {};
 export function resultType(op: string): string | null;
 export namespace SECTION {
     export let custom: number;

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

@@ -1 +1 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../src/const.js"],"names":[],"mappings":"AAIA,0CA0KC;AAYM,+BAHI,MAAM,GACJ,MAAM,GAAC,IAAI,CAavB"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../src/const.js"],"names":[],"mappings":"AAgKa,wBAAW;AAAE,qBAAQ;AAoB3B,+BAHI,MAAM,GACJ,MAAM,GAAC,IAAI,CAavB"}

package/types/src/encode.d.ts

@@ -6,14 +6,7 @@
  * @returns {number[]} 5-byte array
  */
 export function uleb5(value: number): number[];
-/**
- * Encode signed LEB128 for i32 values.
- *
- * @param {number|string} n - Signed 32-bit value
- * @param {number[]} [buffer=[]] - Output buffer
- * @returns {number[]} Encoded bytes
- */
-export function i32(n: number | string, buffer?: number[]): number[];
+export function i32(n: any, buffer?: any[]): any[];
 export namespace i32 {
     function parse(n: any): any;
 }
@@ -28,32 +21,18 @@ export function i64(n: bigint | string, buffer?: number[]): number[];
 export namespace i64 {
     function parse(n: any): any;
 }
-export function f32(input: any, value: any, idx: any): number[];
+export function f32(input: any, out: any, value: any, idx: any): number[];
 export namespace f32 {
     function parse(input: any): number;
 }
-export function f64(input: any, value: any, idx: any): number[];
+export function f64(input: any, out: any, value: any, idx: any): any;
 export namespace f64 {
     function parse(input: any, max?: number): number;
 }
 export function uleb(n: number | bigint | string | null, buffer?: number[]): number[];
-/**
- * Encode signed LEB128 for i32 values.
- *
- * @param {number|string} n - Signed 32-bit value
- * @param {number[]} [buffer=[]] - Output buffer
- * @returns {number[]} Encoded bytes
- */
-export function i8(n: number | string, buffer?: number[]): number[];
+export function i8(n: any, buffer?: any[]): any[];
 export namespace i8 { }
-/**
- * Encode signed LEB128 for i32 values.
- *
- * @param {number|string} n - Signed 32-bit value
- * @param {number[]} [buffer=[]] - Output buffer
- * @returns {number[]} Encoded bytes
- */
-export function i16(n: number | string, buffer?: number[]): number[];
+export function i16(n: any, buffer?: any[]): any[];
 export namespace i16 { }
 export function v128(input: any): any[];
 //# sourceMappingURL=encode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/encode.js"],"names":[],"mappings":"AA6CA;;;;;;GAMG;AACH,6BAHW,MAAM,GACJ,MAAM,EAAE,CAapB;AAED;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAepB;;IAQD,4BAIC;;AAED;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAoBpB;;IAID,4BAmBC;;AAGD,gEAiBC;;IAoED,mCAA6D;;AAjE7D,gEAiBC;;IAED,iDA4CC;;AA1NM,wBAJI,MAAM,GAAC,MAAM,GAAC,MAAM,GAAC,IAAI,WACzB,MAAM,EAAE,GACN,MAAM,EAAE,CA8BpB;AAsBD;;;;;;GAMG;AACH,sBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAepB;;AApBD;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAepB;;AAwJM,wCAKN"}
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/encode.js"],"names":[],"mappings":"AA6CA;;;;;;GAMG;AACH,6BAHW,MAAM,GACJ,MAAM,EAAE,CAapB;AAYD,mDAqBC;;IAQD,4BAIC;;AAED;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAoBpB;;IAID,4BAmBC;;AAGD,0EAkBC;;IAiFD,mCAA6D;;AA7E7D,qEA6BC;;IAED,iDA4CC;;AAnPM,wBAJI,MAAM,GAAC,MAAM,GAAC,MAAM,GAAC,IAAI,WACzB,MAAM,EAAE,GACN,MAAM,EAAE,CA8BpB;AAgCD,kDAqBC;;AArBD,mDAqBC;;AAsKM,wCAKN"}

package/types/src/optimize.d.ts

@@ -18,12 +18,8 @@ export function binarySize(ast: any[]): number;
  * @returns {Array}
  */
 export function treeshake(ast: any[]): any[];
-/**
- * Fold constant expressions.
- * @param {Array} ast
- * @returns {Array}
- */
-export function fold(ast: any[]): any[];
+/** Constant folding as a standalone pass. */
+export function fold(ast: any): any;
 /**
  * Remove dead code after control flow terminators.
  * @param {Array} ast
@@ -37,25 +33,53 @@ export function deadcode(ast: any[]): any[];
  * @returns {Array}
  */
 export function localReuse(ast: any[]): any[];
+/** Identity elimination as a standalone pass. */
+export function identity(ast: any): any;
+/** Strength reduction as a standalone pass. */
+export function strength(ast: any): any;
+/**
+ * Simplify branches with constant conditions.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function branch(ast: any[]): any[];
+export function propagate(ast: any): any;
 /**
- * Remove identity operations.
+ * Merge alias locals: `(local.set $A (local.tee $B V))` writes the same value into
+ * two slots. When that is the ONLY write either local ever gets, their write
+ * histories are identical — every read of $A (even one sequenced before the def,
+ * which sees the zero default on both) equals the same read of $B. So $A's reads
+ * rename to $B and the alias write drops. Params are excluded ($B would carry a
+ * call-argument value where $A held zero).
  * @param {Array} ast
  * @returns {Array}
  */
-export function identity(ast: any[]): any[];
+export function mergeLocals(ast: any[]): any[];
 /**
- * Strength reduction: replace expensive ops with cheaper equivalents.
+ * Local common-subexpression elimination: identical pure subtrees repeated within a
+ * straight-line scope compute once into a fresh local (first site tees, later sites
+ * get). Grouping stops at every invalidation: a statement that writes a local the
+ * expression reads, writes memory (for memory-reading exprs), or calls out (memory/
+ * global-reading exprs). Candidates come only from the unconditional part of each
+ * statement — nested control bodies are separate scopes with their own table.
+ * Fires only when the byte win is provable: (n−1)·bytes(expr) > tee+gets+decl cost.
  * @param {Array} ast
  * @returns {Array}
  */
-export function strength(ast: any[]): any[];
+export function cse(ast: any[]): any[];
 /**
- * Simplify branches with constant conditions.
+ * Macro inlining: a function whose whole body is ONE small expression using each
+ * param exactly once, in declaration order, expands at every call site by
+ * substituting the arguments positionally — no wrapper, no locals, argument
+ * evaluation order preserved verbatim (so impure args stay sound). The husk loses
+ * its callers and treeshake collects it; the expansion feeds fold/offset/cse.
  * @param {Array} ast
  * @returns {Array}
  */
-export function branch(ast: any[]): any[];
-export function propagate(ast: any): any;
+export function inlineMacro(ast: any[], { pin }?: {
+    pin?: any;
+}): any[];
+export function tailmerge(ast: any): any;
 export function inline(ast: any, { simdOnly, pin }?: {
     simdOnly?: boolean;
     pin?: any;
@@ -137,12 +161,8 @@ export const OPTS: any;
  * @returns {Array}
  */
 export function vacuum(ast: any[]): any[];
-/**
- * Apply peephole optimizations.
- * @param {Array} ast
- * @returns {Array}
- */
-export function peephole(ast: any[]): any[];
+/** Peephole rules as a standalone pass. */
+export function peephole(ast: any): any;
 /**
  * Replace `global.get` of an immutable, const-initialised global with the
  * constant — but only when it doesn't grow the module. A `global.get` costs
@@ -158,12 +178,7 @@ export function peephole(ast: any[]): any[];
 export function globals(ast: any[]): any[];
 /** Match (type.load/store (i32.add ptr (type.const N))) and fold offset */
 export function offset(ast: any): any;
-/**
- * Remove br to a block's own label when it is the last instruction.
- * @param {Array} ast
- * @returns {Array}
- */
-export function unbranch(ast: any[]): any[];
+export function unbranch(ast: any): any;
 /**
  * Collapse the `while`-emit idiom into a single loop.
  *
@@ -196,14 +211,7 @@ export function loopify(ast: any[]): any[];
  * @returns {Array}
  */
 export function stripmut(ast: any[]): any[];
-/**
- * Simplify (if cond (then (br $label))) → (br_if $label cond)
- * and (if cond (then) (else (br $label))) → (br_if $label (i32.eqz cond))
- * Only when the br is the sole instruction in the arm.
- * @param {Array} ast
- * @returns {Array}
- */
-export function brif(ast: any[]): any[];
+export function brif(ast: any): any;
 /**
  * Fold identical trailing code out of if/else arms.
  * (if cond (then A X) (else B X)) → (if cond (then A) (else B)) X

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

@@ -1 +1 @@
-{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAsxHA,gEA6FC;AA/zHD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAOlB;AA8CD;;;;;GAKG;AACH,6CAgJC;AAwUD;;;;GAIG;AACH,wCAkDC;AA0YD;;;;GAIG;AACH,4CAqBC;AA+CD;;;;;GAKG;AACH,8CAmDC;AAndD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CAwDC;AAID;;;;GAIG;AACH,0CA6CC;AAuyBD,yCAqCC;AAmND;;;QAqEC;AAuQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;UA+IC;AA/aD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAwOC;AA0gDD;;;;;;;;GAQG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAc/B;AAvBD,qEAAqE;AACrE,uBAA8D;AArlC9D;;;;;GAKG;AACH,0CA8DC;AA+ED;;;;GAIG;AACH,4CAQC;AAiCD;;;;;;;;;;;GAWG;AACH,2CAyDC;AAID,2EAA2E;AAC3E,sCAgEC;AAID;;;;GAIG;AACH,4CAyCC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CAiDC;AAID;;;;;GAKG;AACH,4CAqBC;AAID;;;;;;GAMG;AACH,wCAmBC;AAID;;;;;GAKG;AACH,4CAiDC;AAoCD;;;;;GAKG;AACH,0CA8DC;AAwWD,uCAyBC;AA7XD;;;;;GAKG;AACH,8CAyEC;AA2ID;;;;GAIG;AACH,4CAyDC;AAqBD;;;;;GAKG;AACH,iDAgBC;AA/sCD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAiFC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDAyFC"}
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AA4lMA,gEA+MC;AArxMD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAOlB;AA8CD;;;;;GAKG;AACH,6CAmSC;AAgbD,6CAA6C;AAC7C,oCAA6C;AA2iB7C;;;;GAIG;AACH,4CAqBC;AAoCD;;;;;GAKG;AACH,8CAkFC;AAvlBD,iDAAiD;AACjD,wCAAqD;AAgErD,+CAA+C;AAC/C,wCAAqD;AAIrD;;;;GAIG;AACH,0CA0KC;AAotED,yCA8EC;AA7HD;;;;;;;;;GASG;AACH,+CAuBC;AA3tBD;;;;;;;;;;GAUG;AACH,uCAsJC;AAED;;;;;;;;GAQG;AACH;;UA8DC;AAkZD,yCA4DC;AAkWD;;;QAqEC;AAuQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;UA2JC;AA3bD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAwOC;AAgjED;;;;;;;;GAQG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAc/B;AAvBD,qEAAqE;AACrE,uBAA8D;AA1iD9D;;;;;GAKG;AACH,0CAyEC;AA8FD,2CAA2C;AAC3C,wCAAqD;AAwDrD;;;;;;;;;;;GAWG;AACH,2CAiHC;AAID,2EAA2E;AAC3E,sCAgEC;AA0BD,wCA0DC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CAiDC;AAID;;;;;GAKG;AACH,4CAqBC;AA6BD,oCAuCC;AAID;;;;;GAKG;AACH,4CAiDC;AAuCD;;;;;GAKG;AACH,0CAqFC;AA2cD,uCAyBC;AAheD;;;;;GAKG;AACH,8CAyEC;AAiLD;;;;GAIG;AACH,4CAsHC;AAqBD;;;;;GAKG;AACH,iDAgBC;AAtjDD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAiFC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDA8JC"}

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

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

package/types/src/util.d.ts

@@ -1,13 +1,8 @@
-/**
- * Throws an error with optional source position.
- * Uses err.src for source and err.loc for default position.
- * If pos provided or err.loc set, appends "at line:col".
- *
- * @param {string} text - Error message
- * @param {number} [pos] - Byte offset in source (defaults to err.loc)
- * @throws {Error}
- */
-export const err: (text: string, pos?: number) => never;
+export function err(text: string, pos?: number): never;
+export function setErrLoc(loc: any): void;
+export function setErrSrc(src: any): void;
+export function getErrLoc(): any;
+export function getErrSrc(): any;
 /** Regex to detect invalid underscore placement in numbers */
 export const sepRE: RegExp;
 /** Regex to match valid integer literals (decimal or hex) */

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

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