watr 4.6.6 → 4.6.8

package/src/polyfill.js

@@ -6,117 +6,7 @@
  */
 
 import parse from './parse.js'
-
-/** Features that can be polyfilled */
-const FEATURES = {
-  funcref: ['ref.func', 'call_ref', 'return_call_ref'],
-  sign_ext: ['i32.extend8_s', 'i32.extend16_s', 'i64.extend8_s', 'i64.extend16_s', 'i64.extend32_s'],
-  nontrapping: ['i32.trunc_sat_f32_s', 'i32.trunc_sat_f32_u', 'i32.trunc_sat_f64_s', 'i32.trunc_sat_f64_u',
-    'i64.trunc_sat_f32_s', 'i64.trunc_sat_f32_u', 'i64.trunc_sat_f64_s', 'i64.trunc_sat_f64_u'],
-  bulk_memory: ['memory.copy', 'memory.fill'],
-  return_call: ['return_call', 'return_call_indirect'],
-  i31ref: ['ref.i31', 'i31.get_s', 'i31.get_u'],
-  extended_const: ['global.get'], // in const context - detected specially
-  multi_value: [], // detected by result count
-  gc: ['struct.new', 'struct.get', 'struct.set', 'array.new', 'array.get', 'array.set', 'array.len',
-    'struct.new_default', 'array.new_default', 'array.new_fixed', 'array.copy'],
-  ref_cast: ['ref.test', 'ref.cast', 'br_on_cast', 'br_on_cast_fail'],
-}
-
-/** All feature names */
-const ALL = Object.keys(FEATURES)
-
-/**
- * Normalize polyfill options to { feature: bool } map.
- * @param {boolean|string|Object} opts
- * @returns {Object} Normalized options
- */
-const normalize = (opts) => {
-  if (opts === true) return Object.fromEntries(ALL.map(f => [f, true]))
-  if (opts === false) return {}
-  if (typeof opts === 'string') {
-    const set = new Set(opts.split(/\s+/).filter(Boolean))
-    return Object.fromEntries(ALL.map(f => [f, set.has(f) || set.has('all')]))
-  }
-  return { ...opts }
-}
-
-/**
- * Walk AST depth-first (pre-order), call fn on each node.
- * @param {any} node
- * @param {Function} fn - (node, parent, idx) => void
- * @param {any} [parent]
- * @param {number} [idx]
- */
-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)
-}
-
-/**
- * Walk AST depth-first (post-order), transform children before parent.
- * @param {any} node
- * @param {Function} fn - (node, parent, idx) => void
- * @param {any} [parent]
- * @param {number} [idx]
- */
-const walkPost = (node, fn, parent, idx) => {
-  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) walkPost(node[i], fn, node, i)
-  fn(node, parent, idx)
-}
-
-/**
- * Detect which polyfillable features are used in AST.
- * @param {Array} ast
- * @returns {Set<string>} Set of feature names
- */
-const detect = (ast) => {
-  const used = new Set()
-
-  // Standard op detection
-  walk(ast, node => {
-    if (typeof node !== 'string') return
-    for (const [feat, ops] of Object.entries(FEATURES)) {
-      if (ops.some(op => node === op || node.startsWith(op + ' '))) used.add(feat)
-    }
-  })
-
-  // Special: extended_const - global.get in global initializer with arithmetic
-  walk(ast, node => {
-    if (!Array.isArray(node) || node[0] !== 'global') return
-    for (const init of node) {
-      if (!Array.isArray(init)) continue
-      if (init[0] === 'i32.add' || init[0] === 'i32.sub' || init[0] === 'i32.mul' ||
-          init[0] === 'i64.add' || init[0] === 'i64.sub' || init[0] === 'i64.mul') {
-        // Check if it contains global.get
-        walk(init, inner => {
-          if (Array.isArray(inner) && inner[0] === 'global.get') used.add('extended_const')
-        })
-      }
-    }
-  })
-
-  // Special: multi_value - functions with >1 result
-  walk(ast, node => {
-    if (!Array.isArray(node) || node[0] !== 'func') return
-    let resultCount = 0
-    for (const part of node) {
-      if (Array.isArray(part) && part[0] === 'result') {
-        resultCount += part.length - 1
-      }
-    }
-    if (resultCount > 1) used.add('multi_value')
-  })
-
-  return used
-}
-
-/**
- * Deep clone AST to avoid mutating original.
- * @param {any} node
- * @returns {any}
- */
-const clone = (node) => Array.isArray(node) ? node.map(clone) : node
+import { walk, walkPost, clone } from './util.js'
 
 /**
  * Find module-level nodes by kind (func, table, etc).
@@ -228,9 +118,6 @@ const funcref = (ast, ctx) => {
   return ast
 }
 
-/** Feature transforms */
-const transforms = { funcref }
-
 // ============================================================================
 // SIGN EXTENSION POLYFILL
 // Transforms sign extension ops to shift pairs (shift left then arithmetic shift right).
@@ -265,8 +152,6 @@ const sign_ext = (ast, ctx) => {
   return ast
 }
 
-transforms.sign_ext = sign_ext
-
 // ============================================================================
 // NON-TRAPPING CONVERSIONS POLYFILL
 // Transforms trunc_sat to conditional clamp with NaN/infinity handling.
@@ -344,8 +229,6 @@ const nontrapping = (ast, ctx) => {
   return ast
 }
 
-transforms.nontrapping = nontrapping
-
 // ============================================================================
 // BULK MEMORY POLYFILL
 // Transforms memory.copy/fill to loop-based implementations.
@@ -451,8 +334,6 @@ const bulk_memory = (ast, ctx) => {
   return ast
 }
 
-transforms.bulk_memory = bulk_memory
-
 // ============================================================================
 // TAIL CALL POLYFILL
 // Transforms return_call/return_call_indirect to trampoline pattern.
@@ -490,8 +371,6 @@ const return_call_transform = (ast, ctx) => {
   return ast
 }
 
-transforms.return_call = return_call_transform
-
 // ============================================================================
 // I31REF POLYFILL
 // Transforms i31ref to i32 with masking.
@@ -526,8 +405,6 @@ const i31ref = (ast, ctx) => {
   return ast
 }
 
-transforms.i31ref = i31ref
-
 // ============================================================================
 // EXTENDED CONST POLYFILL
 // Evaluates extended constant expressions at compile time.
@@ -619,8 +496,6 @@ const extended_const = (ast, ctx) => {
   return ast
 }
 
-transforms.extended_const = extended_const
-
 // ============================================================================
 // MULTI-VALUE POLYFILL
 // Transforms multi-value returns to single value + memory/global storage.
@@ -695,8 +570,6 @@ const multi_value = (ast, ctx) => {
   return ast
 }
 
-transforms.multi_value = multi_value
-
 // ============================================================================
 // GC (STRUCT/ARRAY) POLYFILL
 // Transforms GC types to linear memory with bump allocator.
@@ -1017,8 +890,6 @@ const gc = (ast, ctx) => {
   return ast
 }
 
-transforms.gc = gc
-
 // ============================================================================
 // REF.TEST / REF.CAST POLYFILL
 // Runtime type checking using type tags stored at offset 0.
@@ -1174,7 +1045,93 @@ const ref_cast = (ast, ctx) => {
   return ast
 }
 
-transforms.ref_cast = ref_cast
+/**
+ * Polyfillable features, in the order their transforms apply. Each entry is
+ * `[name, triggerOps, transform]` — the single source of truth for detection,
+ * the public `FEATURES` catalogue, and the dispatch loop below.
+ *   - name       — feature key callers toggle (`polyfill: 'funcref gc'`)
+ *   - triggerOps — instruction names whose presence means the feature is used
+ *   - transform  — the lowering pass, `(ast, ctx) => ast`
+ */
+const POLYFILLS = [
+  ['funcref',        ['ref.func', 'call_ref', 'return_call_ref'], funcref],
+  ['sign_ext',       ['i32.extend8_s', 'i32.extend16_s', 'i64.extend8_s', 'i64.extend16_s', 'i64.extend32_s'], sign_ext],
+  ['nontrapping',    ['i32.trunc_sat_f32_s', 'i32.trunc_sat_f32_u', 'i32.trunc_sat_f64_s', 'i32.trunc_sat_f64_u',
+                      'i64.trunc_sat_f32_s', 'i64.trunc_sat_f32_u', 'i64.trunc_sat_f64_s', 'i64.trunc_sat_f64_u'], nontrapping],
+  ['bulk_memory',    ['memory.copy', 'memory.fill'], bulk_memory],
+  ['return_call',    ['return_call', 'return_call_indirect'], return_call_transform],
+  ['i31ref',         ['ref.i31', 'i31.get_s', 'i31.get_u'], i31ref],
+  ['extended_const', ['global.get'], extended_const],  // global.get in a const initializer — also detected specially
+  ['multi_value',    [], multi_value],                 // functions with >1 result — detected by result count
+  ['gc',             ['struct.new', 'struct.get', 'struct.set', 'array.new', 'array.get', 'array.set', 'array.len',
+                      'struct.new_default', 'array.new_default', 'array.new_fixed', 'array.copy'], gc],
+  ['ref_cast',       ['ref.test', 'ref.cast', 'br_on_cast', 'br_on_cast_fail'], ref_cast],
+]
+
+/** Feature name → trigger-op list — the public catalogue of polyfillable features. */
+const FEATURES = Object.fromEntries(POLYFILLS.map(p => [p[0], p[1]]))
+
+/**
+ * Normalize polyfill options to a { feature: bool } map. `true` enables every
+ * feature, a string enables only the named ones (or all via `'all'`), and an
+ * explicit object is passed through untouched.
+ *
+ * @param {boolean|string|Object} opts
+ * @returns {Object} Normalized options
+ */
+const normalize = (opts) => {
+  if (opts === false) return {}
+  if (opts !== true && typeof opts !== 'string') return { ...opts }
+  const set = typeof opts === 'string' ? new Set(opts.split(/\s+/).filter(Boolean)) : null
+  const m = {}
+  for (const p of POLYFILLS) m[p[0]] = set ? (set.has('all') || set.has(p[0])) : true
+  return m
+}
+
+/**
+ * Detect which polyfillable features an AST uses.
+ *
+ * @param {Array} ast
+ * @returns {Set<string>} Set of feature names
+ */
+const detect = (ast) => {
+  const used = new Set()
+
+  // Standard op detection: a trigger op anywhere means its feature is used.
+  walk(ast, node => {
+    if (typeof node !== 'string') return
+    for (const p of POLYFILLS) {
+      const ops = p[1]
+      if (ops.some(op => node === op || node.startsWith(op + ' '))) used.add(p[0])
+    }
+  })
+
+  // Special: extended_const — global.get in a global initializer with arithmetic
+  walk(ast, node => {
+    if (!Array.isArray(node) || node[0] !== 'global') return
+    for (const init of node) {
+      if (!Array.isArray(init)) continue
+      if (init[0] === 'i32.add' || init[0] === 'i32.sub' || init[0] === 'i32.mul' ||
+          init[0] === 'i64.add' || init[0] === 'i64.sub' || init[0] === 'i64.mul') {
+        walk(init, inner => {
+          if (Array.isArray(inner) && inner[0] === 'global.get') used.add('extended_const')
+        })
+      }
+    }
+  })
+
+  // Special: multi_value — functions with >1 result
+  walk(ast, node => {
+    if (!Array.isArray(node) || node[0] !== 'func') return
+    let resultCount = 0
+    for (const part of node) {
+      if (Array.isArray(part) && part[0] === 'result') resultCount += part.length - 1
+    }
+    if (resultCount > 1) used.add('multi_value')
+  })
+
+  return used
+}
 
 /**
  * Apply polyfill transforms to AST.
@@ -1199,10 +1156,9 @@ export default function polyfill(ast, opts = true) {
   const used = detect(ast)
   const ctx = { uid: 0 }
 
-  for (const feat of ALL) {
-    if (used.has(feat) && opts[feat] !== false && transforms[feat]) {
-      ast = transforms[feat](ast, ctx)
-    }
+  for (const p of POLYFILLS) {
+    const fn = p[2]
+    if (used.has(p[0]) && opts[p[0]] !== false) ast = fn(ast, ctx)
   }
 
   return ast

package/src/template.js

@@ -0,0 +1,245 @@
+/**
+ * Tagged-template `compile` / `watr` over swappable backend primitives.
+ *
+ * The tagged-template entry point (`.raw` detection), interpolated function
+ * imports, and `new WebAssembly.Module` instantiation are JS-host concerns the
+ * wasm boundary cannot express — so they live here, once, backend-agnostic.
+ * watr.js wires the JS-source backend; the wasm test runner wires wasm exports.
+ *
+ * jz constraint: backend primitives must be destructured into locals before
+ * being called — jz miscompiles a direct `backend.fn()` property call, and
+ * cannot host these as a nested factory closure. Hence top-level functions
+ * taking `backend` as a plain argument.
+ *
+ * @module watr/template
+ */
+
+import { resultType } from './const.js'
+
+/** Private Use Area character as placeholder for interpolation */
+const PUA = '\uE000'
+
+/**
+ * Infer type of an expression AST node.
+ * Used for auto-import parameter type inference.
+ *
+ * @param {any} node - AST node (array or primitive)
+ * @param {Object} [ctx={}] - Context with locals/funcs type info
+ * @returns {string|null} Type string or null if unknown
+ */
+const exprType = (node, ctx = {}) => {
+  if (!Array.isArray(node)) {
+    // local.get $x - lookup type
+    if (typeof node === 'string' && node[0] === '$' && ctx.locals?.[node]) return ctx.locals[node]
+    return null
+  }
+  const [op, ...args] = node
+  // (i32.const 42) → i32
+  const rt = resultType(op)
+  if (rt) return rt
+  // (local.get $x) → lookup
+  if (op === 'local.get' && ctx.locals?.[args[0]]) return ctx.locals[args[0]]
+  // (call $fn ...) → lookup function result type
+  if (op === 'call' && ctx.funcs?.[args[0]]) return ctx.funcs[args[0]].result?.[0]
+  return null
+}
+
+/**
+ * Walk AST and transform nodes depth-first.
+ * Handles array splicing when child has `_splice` property.
+ *
+ * @param {any} node - AST node to walk
+ * @param {Function} fn - Transform function (node) => node
+ * @returns {any} Transformed node
+ */
+function walk(node, fn) {
+  node = fn(node)
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) {
+      let child = walk(node[i], fn)
+      if (child?._splice) node.splice(i, 1, ...child), i += child.length - 1
+      else node[i] = child
+    }
+  }
+  return node
+}
+
+/**
+ * Find function references in AST and infer import signatures.
+ * Scans for `(call fn args...)` where fn is a JS function,
+ * infers param types from arguments, generates import entries.
+ *
+ * @param {Array} ast - AST to scan
+ * @param {Function[]} funcs - Functions to look for
+ * @returns {Array<{idx: number, name: string, params: string[], fn: Function}>} Import entries
+ */
+function inferImports(ast, funcs) {
+  const imports = []
+  const importMap = new Map() // fn → import index
+
+  walk(ast, node => {
+    if (!Array.isArray(node)) return node
+
+    // Find (call ${fn} args...) where fn is a function
+    if (node[0] === 'call' && typeof node[1] === 'function') {
+      const fn = node[1]
+
+      if (!importMap.has(fn)) {
+        // Infer param types from arguments
+        const params = []
+        for (let i = 2; i < node.length; i++) {
+          const t = exprType(node[i])
+          if (t) params.push(t)
+        }
+
+        // Create import entry
+        const idx = imports.length
+        const name = fn.name || `$fn${idx}`
+        importMap.set(fn, { idx, name: name.startsWith('$') ? name : '$' + name, params, fn })
+        imports.push(importMap.get(fn))
+      }
+
+      // Replace function with import reference
+      const imp = importMap.get(fn)
+      node[1] = imp.name
+    }
+
+    return node
+  })
+
+  return imports
+}
+
+/**
+ * Generate WAT import declarations from inferred imports.
+ *
+ * @param {Array<{name: string, params: string[]}>} imports - Import entries
+ * @returns {Array} AST nodes for import declarations
+ */
+function genImports(imports) {
+  return imports.map(({ name, params }) =>
+    ['import', '"env"', `"${name.slice(1)}"`, ['func', name, ...params.map(t => ['param', t])]]
+  )
+}
+
+/**
+ * Compile WAT to binary. Supports string, AST, and tagged template.
+ *
+ * @param {Object} backend - { parse, compile, optimize, polyfill } primitives
+ * @param {string|Array|TemplateStringsArray} source - WAT source, AST, or template strings
+ * @param {any[]} values - Interpolation values (for template literal)
+ *   Last value can be options object:
+ *   - polyfill: true | 'funcref sign_ext' | { funcref: true }
+ *   - optimize: true | 'fold treeshake' | { fold: true }
+ * @returns {Uint8Array} WebAssembly binary
+ */
+export function compile(backend, source, values) {
+  // Destructure into locals: jz miscompiles a direct backend.fn() call.
+  const { parse, compile: emit, optimize, polyfill } = backend
+
+  // 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].byteLength) {
+    opts = values.pop()
+  }
+
+  // Template literal: source is TemplateStringsArray
+  if (Array.isArray(source) && source.raw) {
+    // Build source with placeholders
+    let src = source[0]
+    for (let i = 0; i < values.length; i++) {
+      src += PUA + source[i + 1]
+    }
+
+    // Parse to AST
+    let ast = parse(src)
+
+    // Collect functions for auto-import
+    const funcsToImport = []
+
+    // Replace placeholders with actual values
+    let idx = 0
+    ast = walk(ast, node => {
+      if (node === PUA) {
+        const value = values[idx++]
+        // Function → mark for import inference
+        if (typeof value === 'function') {
+          funcsToImport.push(value)
+          return value // keep function reference for now
+        }
+        // String containing WAT code → parse and splice
+        if (typeof value === 'string' && (value[0] === '(' || /^\s*\(/.test(value))) {
+          const parsed = parse(value)
+          if (Array.isArray(parsed) && Array.isArray(parsed[0])) {
+            parsed._splice = true
+          }
+          return parsed
+        }
+        // Uint8Array → convert to plain array for flat() compatibility
+        if (value?.byteLength !== undefined) return [...value]
+        // BigInt can't cross the wasm boundary as a value, and watr's i32
+        // encoder rejects it — a decimal string parses back for both i32/i64.
+        if (typeof value === 'bigint') return value.toString()
+        return value
+      }
+      return node
+    })
+
+    // If we have functions to import, infer and generate imports
+    let importObjs = null
+    if (funcsToImport.length) {
+      const imports = inferImports(ast, funcsToImport)
+      if (imports.length) {
+        // Insert import declarations at start of module
+        const importDecls = genImports(imports)
+        if (ast[0] === 'module') {
+          ast.splice(1, 0, ...importDecls)
+        } else if (typeof ast[0] === 'string') {
+          // Single top-level node like ['func', ...] - wrap in array with imports
+          ast = [...importDecls, ast]
+        } else {
+          // Multiple top-level nodes like [['func', ...], ['func', ...]]
+          ast.unshift(...importDecls)
+        }
+        // Build imports object for instantiation
+        importObjs = { env: {} }
+        for (const imp of imports) {
+          importObjs.env[imp.name.slice(1)] = imp.fn
+        }
+      }
+    }
+
+    // Apply transforms
+    if (opts.polyfill) ast = polyfill(ast, opts.polyfill)
+    if (opts.optimize) ast = optimize(ast, opts.optimize)
+
+    const binary = emit(ast)
+    // Attach imports for watr() to use
+    if (importObjs) binary._imports = importObjs
+    return binary
+  }
+
+  // String/AST source with options
+  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 emit(ast)
+  }
+  return emit(source)
+}
+
+/**
+ * Compile and instantiate WAT, returning exports.
+ *
+ * @param {Object} backend - { parse, compile, optimize, polyfill } primitives
+ * @param {string|Array|TemplateStringsArray} source - WAT source, AST, or template strings
+ * @param {any[]} values - Interpolation values (for template literal)
+ * @returns {WebAssembly.Exports} Module exports
+ */
+export function watr(backend, source, values) {
+  const binary = compile(backend, source, values)
+  const module = new WebAssembly.Module(binary)
+  const instance = new WebAssembly.Instance(module, binary._imports)
+  return instance.exports
+}

package/src/util.js

@@ -19,13 +19,6 @@ export const err = (text, pos=err.loc) => {
   throw Error(text)
 }
 
-/**
- * Deep clone an array tree structure.
- * @param {Array} items - Array to clone
- * @returns {Array} Cloned array
- */
-export const clone = items => items.map(item => Array.isArray(item) ? clone(item) : item)
-
 /** Regex to detect invalid underscore placement in numbers */
 export const sepRE = /^_|_$|[^\da-f]_|_[^\da-f]/i
 
@@ -84,3 +77,46 @@ export const str = s => {
  * @returns {string} Unescaped string without quotes, e.g. 'hello\nworld'
  */
 export const unescape = s => tdec.decode(new Uint8Array(str(s)))
+
+
+// AST traversal — every watr AST node is an s-expression array `[head, ...args]`.
+
+/**
+ * Deep clone an AST node.
+ * @param {any} node
+ * @returns {any}
+ */
+export const clone = (node) => Array.isArray(node) ? node.map(clone) : node
+
+/**
+ * Walk AST depth-first (pre-order), call fn on each node. Read-only.
+ * @param {any} node
+ * @param {Function} fn - (node, parent, idx) => void
+ * @param {any} [parent]
+ * @param {number} [idx]
+ */
+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)
+}
+
+/**
+ * Walk AST depth-first (post-order): children are visited before their parent.
+ *
+ * A node is replaced either way a callback chooses to express it:
+ *   - return a new node — walkPost writes it into `parent[idx]`
+ *   - mutate `parent[idx]` in place and return undefined — walkPost leaves it
+ * so both the transforming (optimize) and mutating (polyfill) styles compose.
+ *
+ * @param {any} node
+ * @param {Function} fn - (node, parent, idx) => newNode | undefined
+ * @param {any} [parent]
+ * @param {number} [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)
+  const result = fn(node, parent, idx)
+  if (result !== undefined && parent) parent[idx] = result
+  return result !== undefined ? result : node
+}

package/types/src/const.d.ts

@@ -1,4 +1,5 @@
 export const INSTR: (string | string[])[];
+export function resultType(op: string): string | null;
 export namespace SECTION {
     export let custom: number;
     export let type: 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"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../src/const.js"],"names":[],"mappings":"AAIA,0CA0KC;AAYM,+BAHI,MAAM,GACJ,MAAM,GAAC,IAAI,CAavB"}

package/types/src/optimize.d.ts

@@ -105,39 +105,17 @@ export function inline(ast: any[]): any[];
  */
 export function inlineOnce(ast: any[]): any[];
 /**
- * Normalize options to { opt: bool } map.
+ * Normalize options to a { passName: bool } map. An explicit object is kept
+ * as-is (preserving `log`/`verbose`), with any unmentioned pass filled to its
+ * default; `true` selects the defaults; a string selects only the named
+ * passes (or all of them via `'all'`).
+ *
  * @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;
-    let inlineOnce: boolean;
-    let vacuum: boolean;
-    let mergeBlocks: boolean;
-    let coalesce: boolean;
-    let peephole: boolean;
-    let globals: boolean;
-    let offset: boolean;
-    let unbranch: boolean;
-    let loopify: 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;
-}
+/** Option name → default-on map — the public catalogue of passes. */
+export const OPTS: any;
 /**
  * Remove no-op code: nops, drop of pure expressions, empty branches,
  * and select with identical arms.

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

@@ -1 +1 @@
-{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AA02FA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAkF/B;AAp5FD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAIlB;AAwGD;;;;;GAKG;AACH,6CAgJC;AAuMD;;;;GAIG;AACH,wCAwBC;AAoMD;;;;GAIG;AACH,4CAqBC;AA+CD;;;;;GAKG;AACH,8CAmDC;AA7QD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CAuCC;AAoeD,yCAoCC;AAID;;;;GAIG;AACH,0CAiGC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8CAmOC;AAvgDD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAa/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6vDD;;;;;GAKG;AACH,0CAgDC;AAyED;;;;GAIG;AACH,4CAQC;AA4BD;;;;;;;;;;;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;AAiWD,uCAyBC;AAtXD;;;;;GAKG;AACH,8CAyEC;AAoID;;;;GAIG;AACH,4CAyDC;AAqBD;;;;;GAKG;AACH,iDAgBC;AA/qCD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAiFC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDAyFC"}
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AA00FA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAyD/B;AA13FD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAIlB;AA8CD;;;;;GAKG;AACH,6CAgJC;AAuMD;;;;GAIG;AACH,wCAuBC;AAoMD;;;;GAIG;AACH,4CAqBC;AA+CD;;;;;GAKG;AACH,8CAmDC;AA7QD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CAuCC;AAoeD,yCAoCC;AAID;;;;GAIG;AACH,0CAgGC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8CAmOC;AAyzCD;;;;;;;;GAQG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAc/B;AAvBD,qEAAqE;AACrE,uBAA8D;AAljC9D;;;;;GAKG;AACH,0CAgDC;AAwED;;;;GAIG;AACH,4CAQC;AA4BD;;;;;;;;;;;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;AAiWD,uCAyBC;AAtXD;;;;;GAKG;AACH,8CAyEC;AAoID;;;;GAIG;AACH,4CAyDC;AAqBD;;;;;GAKG;AACH,iDAgBC;AA9qCD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAiFC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDAyFC"}