watr 4.3.3 → 4.4.0

package/types/src/optimize.d.ts

@@ -56,12 +56,11 @@ export function strength(ast: any[]): any[];
  */
 export function branch(ast: any[]): any[];
 /**
- * Propagate constant values through local variables.
- * When a local is set to a constant and not modified before use, replace the get with the constant.
- * @param {Array} ast
- * @returns {Array}
+ * Propagate values through locals and eliminate single-use/dead locals.
+ * Constants propagate to all uses; pure single-use exprs inline into get site.
+ * Multi-pass with batch counting for convergence.
  */
-export function propagate(ast: any[]): any[];
+export function propagate(ast: any): any;
 /**
  * Inline tiny functions (single expression, no locals, no params or simple params).
  * @param {Array} ast
@@ -84,5 +83,95 @@ export namespace OPTS {
     let branch: boolean;
     let propagate: boolean;
     let inline: boolean;
+    let vacuum: boolean;
+    let peephole: boolean;
+    let globals: boolean;
+    let offset: boolean;
+    let unbranch: boolean;
+    let stripmut: boolean;
+    let brif: boolean;
+    let foldarms: boolean;
+    let dedupe: boolean;
+    let reorder: boolean;
+    let dedupTypes: boolean;
+    let packData: boolean;
+    let minifyImports: boolean;
 }
+/**
+ * Remove no-op code: nops, drop of pure expressions, empty branches,
+ * and select with identical arms.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function vacuum(ast: any[]): any[];
+/**
+ * Apply peephole optimizations.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function peephole(ast: any[]): any[];
+/**
+ * Replace global.get of immutable globals with their constant init values.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+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[];
+/**
+ * Strip mutability from globals that are never written.
+ * Enables globals constant-propagation for more globals.
+ * @param {Array} ast
+ * @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[];
+/**
+ * Fold identical trailing code out of if/else arms.
+ * (if cond (then A X) (else B X)) → (if cond (then A) (else B)) X
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function foldarms(ast: any[]): any[];
+/**
+ * Eliminate duplicate functions by hashing bodies.
+ * Keeps the first occurrence and redirects all references to it.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function dedupe(ast: any[]): any[];
+export function reorder(ast: any): any;
+/**
+ * Merge structurally identical (type ...) definitions.
+ * Keeps the first occurrence and redirects all references.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function dedupTypes(ast: any[]): any[];
+/**
+ * Pack data segments: trim trailing zeros and merge adjacent constant-offset segments.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function packData(ast: any[]): any[];
+/**
+ * Minify import module and field names for smaller binaries.
+ * Only safe when you control the host environment.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function minifyImports(ast: any[]): any[];
 //# sourceMappingURL=optimize.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAioCA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAwB/B;AAtkCD;;;;;GAKG;AACH,6CA8LC;AAyHD;;;;GAIG;AACH,wCAmCC;AAwQD;;;;GAIG;AACH,4CAuBC;AA+CD;;;;;GAKG;AACH,8CAqDC;AApTD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CA0EC;AAiJD;;;;;GAKG;AACH,6CAuEC;AAID;;;;GAIG;AACH,0CAwFC;AAn+BD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAe/B"}
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AA2+DA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SA6C/B;AA34DD;;;;;GAKG;AACH,6CAsIC;AA6ID;;;;GAIG;AACH,wCAwBC;AAoMD;;;;GAIG;AACH,4CAuBC;AA+CD;;;;;GAKG;AACH,8CAqDC;AAjRD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CAuCC;AAwVD;;;;GAIG;AACH,yCAwBC;AAID;;;;GAIG;AACH,0CAwFC;AApiCD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAgB/B;;;;;;;;;;;;;;;;;;;;;;;;;AAshCD;;;;;GAKG;AACH,0CAgDC;AAyED;;;;GAIG;AACH,4CAQC;AAID;;;;GAIG;AACH,2CA0CC;AAID,2EAA2E;AAC3E,sCAgEC;AAID;;;;GAIG;AACH,4CAuCC;AAID;;;;;GAKG;AACH,4CAsBC;AAID;;;;;;GAMG;AACH,wCAmBC;AAID;;;;;GAKG;AACH,4CAsCC;AAoCD;;;;;GAKG;AACH,0CA+DC;AAoWD,uCA0BC;AA1XD;;;;;GAKG;AACH,8CA0EC;AAoID;;;;GAIG;AACH,4CA0DC;AAqBD;;;;;GAKG;AACH,iDAiBC"}

package/watr.js

@@ -152,7 +152,7 @@ function genImports(imports) {
 function compile(source, ...values) {
   // Options object as last argument (non-template call)
   let opts = {}
-  if (!Array.isArray(source) && values.length && typeof values[values.length - 1] === 'object' && values[values.length - 1] !== null && !(values[values.length - 1] instanceof Uint8Array)) {
+  if (!Array.isArray(source) && values.length && typeof values[values.length - 1] === 'object' && values[values.length - 1] !== null && !values[values.length - 1].byteLength) {
     opts = values.pop()
   }
 
@@ -189,7 +189,7 @@ function compile(source, ...values) {
           return parsed
         }
         // Uint8Array → convert to plain array for flat() compatibility
-        if (value instanceof Uint8Array) return [...value]
+        if (value.byteLength !== undefined) return [...value]
         return value
       }
       return node