watr 4.1.0 → 4.2.1

package/src/parse.js

@@ -2,7 +2,7 @@ import { err } from "./util.js"
 
 /**
  * Parses a wasm text string and constructs a nested array structure (AST).
- * Each array node has `.i` property with source offset for error reporting.
+ * Each array node has `.loc` property with source offset for error reporting.
  *
  * @param {string} str - The input string with WAT code to parse.
  * @returns {Array} An array representing the nested syntax tree (AST).
@@ -13,7 +13,7 @@ export default (str) => {
   const commit = () => buf && (level.push(buf), buf = '')
 
   const parseLevel = (pos) => {
-    level.i = pos // store start position for error reporting
+    level.loc = pos // store start position for error reporting
     for (let c, root, p; i < str.length;) {
       c = str.charCodeAt(i)
 

package/src/util.js

@@ -1,13 +1,13 @@
 /**
  * Throws an error with optional source position.
- * Uses err.src for source and err.i for default position.
- * If pos provided or err.i set, appends "at line:col".
+ * 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.i)
+ * @param {number} [pos] - Byte offset in source (defaults to err.loc)
  * @throws {Error}
  */
-export const err = (text, pos=err.i) => {
+export const err = (text, pos=err.loc) => {
   if (pos != null && err.src) {
     let line = 1, col = 1
     for (let i = 0; i < pos && i < err.src.length; i++) {

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

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,uCAHW,MAAM,QAAM,GACV,UAAU,CAmLtB"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,uCAHW,MAAM,QAAM,GACV,UAAU,CA6LtB"}

package/types/src/optimize.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Optimize AST.
+ *
+ * @param {Array|string} ast - AST or WAT source
+ * @param {boolean|string|Object} [opts=true] - Optimization options
+ * @returns {Array} Optimized AST
+ *
+ * @example
+ * optimize(ast)                      // all optimizations
+ * optimize(ast, 'treeshake')         // only treeshake
+ * optimize(ast, { fold: true })      // explicit
+ */
+export default function optimize(ast: any[] | string, opts?: boolean | string | any): any[];
+/**
+ * Remove unused functions, globals, types, tables.
+ * Keeps exports and their transitive dependencies.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function treeshake(ast: any[]): any[];
+/**
+ * Fold constant expressions.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function fold(ast: any[]): any[];
+/**
+ * Remove dead code after control flow terminators.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function deadcode(ast: any[]): any[];
+/**
+ * Reuse locals of the same type to reduce total local count.
+ * Basic version: deduplicate unused locals.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function localReuse(ast: any[]): any[];
+/**
+ * Remove identity operations.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function identity(ast: any[]): any[];
+/**
+ * Strength reduction: replace expensive ops with cheaper equivalents.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function strength(ast: any[]): any[];
+/**
+ * Simplify branches with constant conditions.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+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}
+ */
+export function propagate(ast: any[]): any[];
+/**
+ * Inline tiny functions (single expression, no locals, no params or simple params).
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function inline(ast: any[]): any[];
+/**
+ * Normalize options to { opt: bool } map.
+ * @param {boolean|string|Object} opts
+ * @returns {Object}
+ */
+export function normalize(opts: boolean | string | any): any;
+export namespace OPTS {
+    let treeshake: boolean;
+    let fold: boolean;
+    let deadcode: boolean;
+    let locals: boolean;
+    let identity: boolean;
+    let strength: boolean;
+    let branch: boolean;
+    let propagate: boolean;
+    let inline: boolean;
+}
+//# sourceMappingURL=optimize.d.ts.map

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

@@ -0,0 +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"}

package/types/src/util.d.ts

@@ -1,10 +1,10 @@
 /**
  * Throws an error with optional source position.
- * Uses err.src for source and err.i for default position.
- * If pos provided or err.i set, appends "at line:col".
+ * 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.i)
+ * @param {number} [pos] - Byte offset in source (defaults to err.loc)
  * @throws {Error}
  */
 export const err: (text: string, pos?: number) => never;

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,MAGwB,WAUlC;AAOM,2CAAkF;AAEzF,8DAA8D;AAC9D,2BAAiD;AAEjD,6DAA6D;AAC7D,2BAAiD;AAe1C,uBAHI,MAAM,GACJ,MAAM,EAAE,CA8BpB;AAUM,4BAHI,MAAM,GACJ,MAAM,CAE6C"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,mBAAoB,MAJT,MAIa,EAAE,MAHf,MAG0B,WAUpC;AAOM,2CAAkF;AAEzF,8DAA8D;AAC9D,2BAAiD;AAEjD,6DAA6D;AAC7D,2BAAiD;AAe1C,uBAHI,MAAM,GACJ,MAAM,EAAE,CA8BpB;AAUM,4BAHI,MAAM,GACJ,MAAM,CAE6C"}

package/types/watr.d.ts

@@ -21,17 +21,20 @@ export function watr(strings: string | TemplateStringsArray, ...values: any[]):
  *
  * @param {string|TemplateStringsArray} source - WAT source or template strings
  * @param {...any} values - Interpolation values (for template literal)
- *   Last value can be options object: { polyfill: true | 'funcref' | { funcref: true } }
+ *   Last value can be options object:
+ *   - polyfill: true | 'funcref sign_ext' | { funcref: true }
+ *   - optimize: true | 'fold treeshake' | { fold: true }
  * @returns {Uint8Array} WebAssembly binary
  *
  * @example
  * compile('(func (export "f") (result i32) (i32.const 42))')
  * compile`(func (export "f") (result f64) (f64.const ${Math.PI}))`
- * compile(src, { polyfill: true })
+ * compile(src, { polyfill: true, optimize: true })
  */
 export function compile(source: string | TemplateStringsArray, ...values: any[]): Uint8Array;
 import parse from './src/parse.js';
 import print from './src/print.js';
 import _polyfill from './src/polyfill.js';
-export { parse, print, _polyfill as polyfill };
+import _optimize from './src/optimize.js';
+export { parse, print, _polyfill as polyfill, _optimize as optimize };
 //# sourceMappingURL=watr.d.ts.map

package/types/watr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watr.d.ts","sourceRoot":"","sources":["../watr.js"],"names":[],"mappings":";AA2OA;;;;;;;;;;;;;;;GAeG;AACH,8BAbW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,WAAW,CAAC,OAAO,CAgB/B;AAzHD;;;;;;;;;;;;GAYG;AACH,gCAVW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GAEJ,UAAU,CA4FtB;kBAlOiB,gBAAgB;kBAChB,gBAAgB;sBACZ,mBAAmB"}
+{"version":3,"file":"watr.d.ts","sourceRoot":"","sources":["../watr.js"],"names":[],"mappings":";AAiPA;;;;;;;;;;;;;;;GAeG;AACH,8BAbW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,WAAW,CAAC,OAAO,CAgB/B;AA9HD;;;;;;;;;;;;;;GAcG;AACH,gCAZW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GAIJ,UAAU,CA+FtB;kBAxOiB,gBAAgB;kBAChB,gBAAgB;sBACZ,mBAAmB;sBACnB,mBAAmB"}

package/watr.js

@@ -8,6 +8,7 @@ import _compile from './src/compile.js'
 import parse from './src/parse.js'
 import print from './src/print.js'
 import _polyfill from './src/polyfill.js'
+import _optimize from './src/optimize.js'
 
 /** Private Use Area character as placeholder for interpolation */
 const PUA = '\uE000'
@@ -138,13 +139,15 @@ function genImports(imports) {
  *
  * @param {string|TemplateStringsArray} source - WAT source or template strings
  * @param {...any} values - Interpolation values (for template literal)
- *   Last value can be options object: { polyfill: true | 'funcref' | { funcref: true } }
+ *   Last value can be options object:
+ *   - polyfill: true | 'funcref sign_ext' | { funcref: true }
+ *   - optimize: true | 'fold treeshake' | { fold: true }
  * @returns {Uint8Array} WebAssembly binary
  *
  * @example
  * compile('(func (export "f") (result i32) (i32.const 42))')
  * compile`(func (export "f") (result f64) (f64.const ${Math.PI}))`
- * compile(src, { polyfill: true })
+ * compile(src, { polyfill: true, optimize: true })
  */
 function compile(source, ...values) {
   // Options object as last argument (non-template call)
@@ -216,8 +219,9 @@ function compile(source, ...values) {
       }
     }
 
-    // Apply polyfill if requested
+    // Apply transforms
     if (opts.polyfill) ast = _polyfill(ast, opts.polyfill)
+    if (opts.optimize) ast = _optimize(ast, opts.optimize)
 
     const binary = _compile(ast)
     // Attach imports for watr() to use
@@ -226,8 +230,10 @@ function compile(source, ...values) {
   }
 
   // String/AST source with options
-  if (opts.polyfill) {
-    const ast = _polyfill(source, opts.polyfill)
+  if (opts.polyfill || opts.optimize) {
+    let ast = typeof source === 'string' ? parse(source) : source
+    if (opts.polyfill) ast = _polyfill(ast, opts.polyfill)
+    if (opts.optimize) ast = _optimize(ast, opts.optimize)
     return _compile(ast)
   }
   return _compile(source)
@@ -257,4 +263,4 @@ function watr(strings, ...values) {
 }
 
 export default watr
-export { watr, compile, parse, print, _polyfill as polyfill }
+export { watr, compile, parse, print, _polyfill as polyfill, _optimize as optimize }