jz 0.3.1 → 0.5.0

package/src/jzify.js

@@ -27,11 +27,14 @@ export default function jzify(ast) {
   argsIdx = 0
   doIdx = 0
   classIdx = 0
+  objThisIdx = 0
+  staticClassIdx = 0
+  classBaseIdx = 0
   // Hoist module-level vars: any `var x` inside nested blocks bubbles up.
   const names = new Set()
   ast = hoistVars(ast, names)
   if (names.size) ast = prependDecls(ast, names)
-  return foldStaticExportHelpers(transformScope(ast))
+  return foldStaticBundlerHelpers(foldStaticExportHelpers(canonicalizeObjectIdioms(transformScope(ast))))
 }
 
 /**
@@ -71,16 +74,27 @@ function hoistVars(node, names) {
     }
     return [op, lhs, hoistVars(node[2], names)]
   }
+  // Labeled statement: recurse into the body so its `var`s hoist to the
+  // enclosing function, not stop at the label.
+  if (op === ':' && typeof node[1] === 'string') {
+    return [':', node[1], hoistVars(node[2], names)]
+  }
   if (op === '=' && Array.isArray(node[1]) && node[1][0] === 'var' && typeof node[1][1] === 'string' && node[1].length === 2) {
     names.add(node[1][1])
     return ['=', node[1][1], hoistVars(node[2], names)]
   }
+  if (op === '=' && isDestructurePat(node[1])) {
+    return ['=', hoistPattern(node[1], names), hoistVars(node[2], names)]
+  }
   // For-head `;` is positional (init; cond; update), not a statement sequence.
   // Recurse into each slot but never filter nulls — empty slots are valid.
   if (op === 'for') {
     const head = node[1]
     let h2
-    if (Array.isArray(head) && head[0] === 'var' && Array.isArray(head[1]) &&
+    const normalizedHead = normalizeForDeclHead(head, names) || normalizeForCommaHead(head, names)
+    if (normalizedHead) {
+      h2 = normalizedHead
+    } else if (Array.isArray(head) && head[0] === 'var' && Array.isArray(head[1]) &&
         (head[1][0] === 'in' || head[1][0] === 'of') && typeof head[1][1] === 'string') {
       names.add(head[1][1])
       h2 = [head[1][0], head[1][1], hoistVars(head[1][2], names)]
@@ -106,25 +120,84 @@ function hoistVars(node, names) {
     if (decls.length === 1) return decls[0]
     return [',', ...decls]
   }
+  if (op === 'let' || op === 'const') {
+    const decls = [op]
+    for (let i = 1; i < node.length; i++) {
+      const d = node[i]
+      if (Array.isArray(d) && d[0] === '=' && isDestructurePat(d[1])) {
+        decls.push(['=', hoistPattern(d[1], names), hoistVars(d[2], names)])
+      } else {
+        decls.push(hoistVars(d, names))
+      }
+    }
+    return decls
+  }
   // Filter null returns from `;` sequences (bare-var no-ops). `{}` is left
   // to recurse normally — it may be either a block or an object literal,
   // and we don't want to clobber `['{}', null]` (empty object literal).
   if (op === ';') {
     const out = [op]
     for (let i = 1; i < node.length; i++) {
-      const c = hoistVars(node[i], names)
+      const child = node[i]
+      // A direct scope-child `var f = <arrow>` keeps its decl shape (→ a single
+      // `let f = arrow`) instead of splitting into a hoisted `let f` + later
+      // assignment. `var` and `let` are equivalent at a direct statement
+      // position, and the single-decl form is what top-level-function
+      // recognition keys on — bundlers (esbuild &c.) emit `var` for every
+      // module binding, so without this every bundled function would degrade
+      // to a closure value (and hit MAX_CLOSURE_ARITY). Redeclarations are
+      // collapsed downstream by the binding-dedup pass.
+      if (Array.isArray(child) && child[0] === 'var' && child.length === 2 &&
+          Array.isArray(child[1]) && child[1][0] === '=' && typeof child[1][1] === 'string' &&
+          Array.isArray(child[1][2]) && child[1][2][0] === '=>') {
+        out.push(['let', ['=', child[1][1], hoistVars(child[1][2], names)]])
+        continue
+      }
+      const c = hoistVars(child, names)
       if (c != null) out.push(c)
     }
     if (out.length === 1) return null
     if (out.length === 2) return out[1]
     return out
   }
+  // Block body: recursing the inner `;` may collapse it to a bare expression
+  // (e.g. `{ v + 1; }` → `['{}', ['+','v',1]]`), which prepare.js would then
+  // mistake for an object literal. Re-wrap as a 1-stmt `;` if the inner was
+  // block-shaped going in but collapsed to a non-statement-op expression.
+  if (op === '{}' && node.length === 2) {
+    const inner = node[1]
+    const wasBlock = inner != null && Array.isArray(inner) && JZ_BLOCK_OPS.has(inner[0])
+    const t = hoistVars(inner, names)
+    if (!wasBlock || t == null) return ['{}', t]
+    const stayed = Array.isArray(t) && JZ_BLOCK_OPS.has(t[0])
+    return ['{}', stayed ? t : [';', t]]
+  }
   const out = new Array(node.length)
   out[0] = op
   for (let i = 1; i < node.length; i++) out[i] = hoistVars(node[i], names)
   return out
 }
 
+function hoistPattern(node, names) {
+  if (node == null || !Array.isArray(node)) return node
+  const op = node[0]
+  if (op === '=') return ['=', hoistPattern(node[1], names), hoistVars(node[2], names)]
+  if (op === ':') return [':', hoistVars(node[1], names), hoistPattern(node[2], names)]
+  if (op === '...') return ['...', hoistPattern(node[1], names)]
+  if (op === '[]' || op === '{}' || op === ',') return [op, ...node.slice(1).map(n => hoistPattern(n, names))]
+  return hoistVars(node, names)
+}
+
+function transformPattern(node) {
+  if (node == null || !Array.isArray(node)) return node
+  const op = node[0]
+  if (op === '=') return ['=', transformPattern(node[1]), transform(node[2])]
+  if (op === ':') return [':', transform(node[1]), transformPattern(node[2])]
+  if (op === '...') return ['...', transformPattern(node[1])]
+  if (op === '[]' || op === '{}' || op === ',') return [op, ...node.slice(1).map(transformPattern)]
+  return transform(node)
+}
+
 function prependDecls(body, names) {
   const decl = ['let', ...names]
   if (Array.isArray(body) && body[0] === ';') return [';', decl, ...body.slice(1)]
@@ -137,9 +210,51 @@ function prependDecls(body, names) {
   return body == null ? decl : [';', decl, body]
 }
 
+function normalizeForDeclHead(head, names) {
+  if (!Array.isArray(head) || (head[0] !== 'var' && head[0] !== 'let' && head[0] !== 'const')) return null
+  const kind = head[0]
+  if (head.length === 2) {
+    const expr = head[1]
+    if (!Array.isArray(expr)) return null
+    if (expr.length >= 3 && Array.isArray(expr[1]) &&
+        (expr[1][0] === 'in' || expr[1][0] === 'of') && typeof expr[1][1] === 'string') {
+      const iter = expr[1]
+      return [iter[0], normalizeForDecl(kind, iter[1], names), hoistVars([expr[0], iter[2], ...expr.slice(2)], names)]
+    }
+    return null
+  }
+  // Comma Expression in a for-in/of head: subscript parses with no for-head
+  // context, so `for (let x in A, B)` becomes a multi-declarator `let` whose
+  // tail declarators are really the rest of a comma Expression. Fold them back
+  // into the iterated source so the comma operator evaluates them in order.
+  if (head.length > 2 && Array.isArray(head[1]) &&
+      (head[1][0] === 'in' || head[1][0] === 'of') && typeof head[1][1] === 'string') {
+    const iter = head[1]
+    return [iter[0], normalizeForDecl(kind, iter[1], names), hoistVars([',', iter[2], ...head.slice(2)], names)]
+  }
+  return null
+}
+
+// Bare-LHS counterpart of the above: `for (x in A, B)` (no declaration) parses
+// as a comma expression whose first operand is the for-in/of head.
+function normalizeForCommaHead(head, names) {
+  if (!Array.isArray(head) || head[0] !== ',' || head.length < 3) return null
+  const iter = head[1]
+  if (!Array.isArray(iter) || (iter[0] !== 'in' && iter[0] !== 'of') || typeof iter[1] !== 'string') return null
+  return [iter[0], iter[1], hoistVars([',', iter[2], ...head.slice(2)], names)]
+}
+
+function normalizeForDecl(kind, name, names) {
+  if (kind === 'var') {
+    names.add(name)
+    return name
+  }
+  return [kind, name]
+}
+
 /** Convert a named function declaration to a hoisted const arrow */
 function hoistFnDecl(name, params, body) {
-  const [p2, b2] = lowerArguments(params, body)
+  const [p2, b2] = lowerArguments(params, functionBodyBlock(body))
   const decl = ['const', ['=', name, ['=>', p2, wrapArrowBody(b2)]]]
   decl._hoisted = true
   return decl
@@ -161,25 +276,6 @@ function transformScope(node) {
     const hoisted = [], rest = []
     for (let i = 0; i < args.length; i++) {
       const stmt = args[i]
-      // Workaround for subscript parser ASI bug: multiline named IIFE
-      // `(function name(){...})();` is parsed as two statements when there are
-      // newlines inside the function body. Reconstruct the single-statement IIFE
-      // so the () handler can desugar it correctly.
-      if (Array.isArray(stmt) && stmt[0] === '()' &&
-          Array.isArray(stmt[1]) && stmt[1][0] === 'function' && stmt[1][1] &&
-          i + 1 < args.length && Array.isArray(args[i + 1]) && args[i + 1][0] === '()') {
-        const merged = ['()', ['()', stmt[1]], args[i + 1][1] ?? null]
-        const t = transform(merged)
-        if (t != null) {
-          if (Array.isArray(t) && t[0] === ';') {
-            for (const s of t.slice(1)) { if (s != null) rest.push(s) }
-          } else {
-            rest.push(t)
-          }
-        }
-        i++
-        continue
-      }
       // Statement-form named function declaration: hoist directly (skip expression handler)
       if (Array.isArray(stmt) && stmt[0] === 'function' && stmt[1]) {
         hoisted.push(hoistFnDecl(stmt[1], stmt[2], stmt[3]))
@@ -225,24 +321,48 @@ function transformScope(node) {
  * wins; a later redeclaration keeps only its initializer, as a plain assignment.
  */
 function dedupeRedecls(stmts) {
-  const nameOf = s => Array.isArray(s) && (s[0] === 'let' || s[0] === 'const' || s[0] === 'var')
-    ? (typeof s[1] === 'string' ? s[1]
-      : Array.isArray(s[1]) && s[1][0] === '=' && typeof s[1][1] === 'string' ? s[1][1] : null)
-    : null
+  // Per-declarator name — bare `x` or `['=', x, init]`; null for patterns.
+  const declName = d => typeof d === 'string' ? d
+    : Array.isArray(d) && d[0] === '=' && typeof d[1] === 'string' ? d[1] : null
   const seen = new Set(), out = []
   for (const s of stmts) {
-    const n = nameOf(s)
-    if (n == null) { out.push(s); continue }
-    if (seen.has(n)) { if (Array.isArray(s[1]) && s[1][0] === '=') out.push(['=', s[1][1], s[1][2]]); continue }
-    seen.add(n); out.push(s)
+    if (!Array.isArray(s) || (s[0] !== 'let' && s[0] !== 'const' && s[0] !== 'var')) { out.push(s); continue }
+    // Walk every declarator: a multi-name bare `let` (the var-hoist
+    // `prependDecls` output) can carry a name already bound by a hoisted
+    // function `const`. Keep only fresh declarators; a redeclaration with an
+    // initializer survives as a plain assignment.
+    const keep = [s[0]], reassign = []
+    for (let i = 1; i < s.length; i++) {
+      const d = s[i], n = declName(d)
+      if (n == null) { keep.push(d); continue }
+      if (seen.has(n)) { if (Array.isArray(d) && d[0] === '=') reassign.push(['=', d[1], d[2]]) }
+      else { seen.add(n); keep.push(d) }
+    }
+    if (keep.length > 1) out.push(keep)
+    for (const r of reassign) out.push(r)
   }
   return out
 }
 
-/** Wrap function body for arrow conversion */
+/** Wrap function body for arrow conversion.
+ *  Produces the canonical block form `['{}', [';', ...stmts]]`: a `{}` whose
+ *  sole child is a `;`-list. A bare single statement (`['{}', stmt]`, from the
+ *  parser eliding the `;` wrapper) would otherwise be mistaken for an object
+ *  literal, so it is `;`-wrapped here too — `function`→arrow conversions bypass
+ *  the `=>` transform handler and must normalize their own bodies. */
 function wrapArrowBody(body) {
   const t = transformScope(body)
-  return Array.isArray(t) && (t[0] === '{}' || t[0] === ';') ? (t[0] === '{}' ? t : ['{}', t]) : ['{}', t]
+  if (!Array.isArray(t)) return ['{}', [';', t]]
+  if (t[0] === ';') return ['{}', t]
+  if (t[0] !== '{}') return ['{}', [';', t]]
+  if (t.length === 2 && !(Array.isArray(t[1]) && t[1][0] === ';')) return ['{}', [';', t[1]]]
+  return t
+}
+
+function functionBodyBlock(body) {
+  if (Array.isArray(body) && body[0] === '{}') return body
+  if (Array.isArray(body) && body[0] === ';') return ['{}', body]
+  return ['{}', [';', body]]
 }
 
 /** Prototype identity check: X.prototype.Y */
@@ -252,6 +372,46 @@ const TYPED_ARRAYS = new Set(['Float64Array','Float32Array','Int32Array','Uint32
   'Int16Array','Uint16Array','Int8Array','Uint8Array',
   'ArrayBuffer','BigInt64Array','BigUint64Array','DataView'])
 
+// Block-shape ops used to detect "this `{}` is a block body, not an object literal".
+// Mirrors analyze.STMT_OPS — kept inline so jzify stays self-contained.
+const JZ_BLOCK_OPS = new Set([';', 'let', 'const', 'var', 'return', 'if', 'for', 'for-in', 'for-of',
+  'while', 'do', 'break', 'continue', 'switch', 'throw', 'try', 'catch', 'finally',
+  '=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '>>=', '<<=', '>>>=', '||=', '&&=', '??=',
+  '++', '--', '()', 'function', 'class', 'import', 'export', 'label'])
+const LABEL_BODY_OPS = new Set([';', 'if', 'for', 'for-in', 'for-of', 'while', 'do', 'switch', 'try', 'throw'])
+
+/** Statically discriminate `x instanceof Ctor` when the LHS's syntactic shape
+ *  already pins down its runtime type. Returns true/false or null (unknown).
+ *  Matches the lhs forms a user might plausibly write: literal arrays, object
+ *  literals, string/number literals, and `new C(...)` whose ctor name is known.
+ *  Stays conservative — anything else returns null and falls back to the runtime
+ *  predicate so behavior is never silently changed. */
+function staticInstanceofFold(val, ctor) {
+  if (typeof ctor !== 'string' || !Array.isArray(val)) return null
+  // Unwrap grouping parens: `(expr)` parses as `['()', expr]`
+  if (val[0] === '()' && val.length === 2) return staticInstanceofFold(val[1], ctor)
+  // Array literal: `[1,2,3]` → `['[]', [',', …]]` (or `['[]']` for empty array)
+  if (val[0] === '[]' && val.length <= 2) return ctor === 'Array' || ctor === 'Object'
+  // Object literal: `{a:1}` → `['{}', [':', …], …]`
+  if (val[0] === '{}') return ctor === 'Object'
+  // Regex literal: `/x/` → `['//', …]`
+  if (val[0] === '//') return ctor === 'RegExp' || ctor === 'Object'
+  // `new C(...)` — `['new', ['()', 'C', args]]` or `['new', 'C']`
+  if (val[0] === 'new') {
+    const inner = val[1]
+    const cname = typeof inner === 'string' ? inner
+      : (Array.isArray(inner) && inner[0] === '()' && typeof inner[1] === 'string') ? inner[1]
+      : null
+    if (cname) return cname === ctor || (cname !== 'Object' && ctor === 'Object')
+  }
+  // Bare primitive: `[null, v]` where v is a primitive — never an instance per JS spec.
+  if (val[0] == null && val.length === 2) {
+    const v = val[1]
+    if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean' || v == null) return false
+  }
+  return null
+}
+
 // `arguments` lowering: regular `function` has implicit `arguments`; arrow doesn't.
 // jzify converts function → arrow, so any `arguments` use must be rewritten to a rest param.
 // Arrow functions inherit `arguments` from enclosing function — don't stop at '=>'.
@@ -349,6 +509,10 @@ function prependParamDecls(decl, body) {
 }
 
 const arrowParams = params => Array.isArray(params) && params[0] === '()' ? params : ['()', params]
+// A method body from jessie is a bare statement / `;`-sequence — wrap it in a
+// `{}` block so the `=>` handler treats it as a function body, not an expression
+// (an unwrapped `;`-seq arrow body produces malformed IR).
+const block = b => Array.isArray(b) && b[0] === '{}' ? b : ['{}', b]
 
 // === class lowering ===
 //
@@ -369,10 +533,19 @@ const arrowParams = params => Array.isArray(params) && params[0] === '()' ? para
 //     return selfN
 //   }
 //
-// Out of scope for now (rejected with a clear message): `extends`/`super`,
-// `static` members, getters/setters, computed/private-via-`#` member names are
-// kept as the literal key string `#name` (jz allows it).
+// Simple inheritance is lowered too: `class D extends B` builds the instance
+// from `B`'s factory — forwarding `super(...)` args, or the derived ctor params
+// when the derived constructor is implicit — then applies D's own fields and
+// methods over it.
+//
+// Out of scope (rejected with a clear message): full `super.foo` property
+// semantics, getters/setters, non-constant computed member names. Private
+// `#name` members are kept as the literal key string `#name` (jz allows it).
 let classIdx = 0
+let objThisIdx = 0
+let staticClassIdx = 0
+let classBaseIdx = 0
+const DEFAULT_DERIVED_CTOR_ARITY = 8
 
 const classBodyItems = (body) =>
   body == null ? [] : Array.isArray(body) && body[0] === ';' ? body.slice(1) : [body]
@@ -389,39 +562,200 @@ function renameThis(node, to) {
   return node.map(n => renameThis(n, to))
 }
 
+function usesThis(node) {
+  if (node === 'this') return true
+  if (!Array.isArray(node)) return false
+  if (node[0] === 'function' || node[0] === 'class') return false
+  if (node[0] === '.' || node[0] === '?.') return usesThis(node[1])
+  if (node[0] === ':') return usesThis(node[2])
+  return node.some(usesThis)
+}
+
+function hasSuperProp(node) {
+  if (!Array.isArray(node)) return false
+  if ((node[0] === '.' || node[0] === '?.') && node[1] === 'super') return true
+  if (node[0] === '[]' && node[1] === 'super') return true
+  return node.some(hasSuperProp)
+}
+
+function isSuperCall(node) {
+  return Array.isArray(node) && node[0] === '()' && node[1] === 'super'
+}
+
+function literalStringKey(node) {
+  return Array.isArray(node) && node[0] == null && typeof node[1] === 'string' ? node[1] : null
+}
+
+function constStringKey(node) {
+  if (typeof node === 'string') return node
+  const lit = literalStringKey(node)
+  if (lit != null) return lit
+  if (Array.isArray(node) && node[0] === '[]') return literalStringKey(node[1])
+  return null
+}
+
+function superMethodName(callee) {
+  if (!Array.isArray(callee)) return null
+  if ((callee[0] === '.' || callee[0] === '?.') && callee[1] === 'super') return callee[2]
+  if (callee[0] === '[]' && callee[1] === 'super') return literalStringKey(callee[2])
+  return null
+}
+
+function collectSuperMethodCalls(node, out = new Set()) {
+  if (!Array.isArray(node)) return out
+  if (node[0] === 'function' || node[0] === 'class') return out
+  if (node[0] === '()') {
+    const name = superMethodName(node[1])
+    if (name) out.add(name)
+  }
+  for (const n of node) collectSuperMethodCalls(n, out)
+  return out
+}
+
+function rewriteSuperMethodCalls(node, baseMethodVars) {
+  if (!Array.isArray(node)) return node
+  if (node[0] === 'function' || node[0] === 'class') return node
+  if (node[0] === '()') {
+    const name = superMethodName(node[1])
+    if (name) {
+      const fn = baseMethodVars.get(name)
+      if (!fn) jzifyError(`super.${name} is not available on the base class`)
+      return ['()', fn, ...node.slice(2).map(n => rewriteSuperMethodCalls(n, baseMethodVars))]
+    }
+  }
+  return node.map(n => rewriteSuperMethodCalls(n, baseMethodVars))
+}
+
+function splitCtorSuper(body) {
+  if (body == null) return { args: null, body }
+  if (isSuperCall(body)) return { args: body.slice(2), body: null }
+  if (Array.isArray(body) && body[0] === '{}') {
+    const inner = splitCtorSuper(body[1])
+    return { args: inner.args, body: ['{}', inner.body] }
+  }
+  if (Array.isArray(body) && body[0] === ';') {
+    const out = [';']
+    let args = null
+    for (const stmt of body.slice(1)) {
+      if (args == null && isSuperCall(stmt)) { args = stmt.slice(2); continue }
+      out.push(stmt)
+    }
+    return { args, body: out.length === 1 ? null : out.length === 2 ? out[1] : out }
+  }
+  return { args: null, body }
+}
+
+// Object shorthand methods and arrow-valued properties both parse as `=>`.
+// Stay conservative: only statement-shaped bodies are receiver methods here;
+// expression-bodied arrows keep their lexical `this` and remain unsupported.
+const OBJ_METHOD_BODY_OPS = new Set([';', 'return', 'if', 'for', 'for-in', 'for-of',
+  'while', 'do', 'switch', 'throw', 'try', 'break', 'continue'])
+
+function objectLiteralProps(args) {
+  const raw = args.length === 1 && Array.isArray(args[0]) && args[0][0] === ',' ? args[0].slice(1) : args
+  return raw.filter(p => p != null)
+}
+
+function isStatementBody(body) {
+  return Array.isArray(body) && OBJ_METHOD_BODY_OPS.has(body[0])
+}
+
+function objectMethodUsesThis(prop) {
+  if (!Array.isArray(prop) || prop[0] !== ':' || typeof prop[1] !== 'string') return false
+  const value = prop[2]
+  if (!Array.isArray(value)) return false
+  if (value[0] === '=>' && isStatementBody(value[2])) return usesThis(value[2])
+  return false
+}
+
+function lowerObjectLiteralThis(args) {
+  const props = objectLiteralProps(args)
+  if (props.length === 0 || !props.some(objectMethodUsesThis)) return null
+  if (!props.every(p => Array.isArray(p) && p[0] === ':' && typeof p[1] === 'string')) return null
+
+  const self = `obj${objThisIdx++}`
+  const litProps = props.map(p => {
+    const value = p[2]
+    if (objectMethodUsesThis(p)) {
+      return [':', p[1], transform(['=>', value[1], block(renameThis(value[2], self))])]
+    }
+    return [':', p[1], transform(value)]
+  })
+  const lit = ['{}', litProps.length === 1 ? litProps[0] : [',', ...litProps]]
+  return ['()', ['()', ['=>', null, ['{}', [';',
+    ['let', ['=', self, lit]],
+    ['return', self]
+  ]]]], null]
+}
+
 function jzifyError(msg) { throw new Error(`jzify: ${msg}`) }
 
 function lowerClass(name, heritage, body) {
-  if (heritage != null) jzifyError('`class … extends …` is not supported yet — flatten the hierarchy or compose explicitly')
   let ctorParams = null, ctorBody = null
-  const methods = [], fields = []
+  const methods = [], fields = [], statics = []
   for (const it of classBodyItems(body)) {
     if (typeof it === 'string') { fields.push([it, null]); continue }   // bare `x;`
     if (!Array.isArray(it)) continue
+    const bareFieldName = constStringKey(it)
+    if (bareFieldName != null) { fields.push([bareFieldName, null]); continue }
     if (it[0] === ':' && Array.isArray(it[2]) && it[2][0] === '=>') {
-      if (typeof it[1] !== 'string') jzifyError('computed class member names are not supported')
-      if (it[1] === 'constructor') { ctorParams = it[2][1]; ctorBody = it[2][2] }
-      else methods.push([it[1], it[2][1], it[2][2]])
+      const key = constStringKey(it[1])
+      if (key == null) jzifyError('non-constant computed class member names are not supported')
+      if (key === 'constructor') { ctorParams = it[2][1]; ctorBody = it[2][2] }
+      else methods.push([key, it[2][1], it[2][2]])
       continue
     }
     if (it[0] === '=') {
       const lhs = it[1]
-      if (Array.isArray(lhs) && lhs[0] === 'static') jzifyError('`static` class members are not supported yet')
-      if (typeof lhs !== 'string') jzifyError('computed/destructured class fields are not supported')
-      fields.push([lhs, it[2]])
+      if (Array.isArray(lhs) && lhs[0] === 'static') {
+        const key = constStringKey(lhs[1])
+        if (key == null) jzifyError('non-constant computed static class fields are not supported')
+        statics.push([key, it[2]])
+        continue
+      }
+      const key = constStringKey(lhs)
+      if (key == null) jzifyError('non-constant computed/destructured class fields are not supported')
+      fields.push([key, it[2]])
+      continue
+    }
+    if (it[0] === 'static') {
+      const key = constStringKey(it[1])
+      if (key != null) {
+        statics.push([key, null])
+        continue
+      }
+    }
+    if (it[0] === 'static' && typeof it[1] === 'string') {
+      statics.push([it[1], null])
+      continue
+    }
+    if (it[0] === 'static' && Array.isArray(it[1]) && it[1][0] === ':' && Array.isArray(it[1][2]) && it[1][2][0] === '=>') {
+      const key = constStringKey(it[1][1])
+      if (key == null) jzifyError('non-constant computed static class member names are not supported')
+      statics.push([key, it[1][2], true])
       continue
     }
     if (it[0] === 'get' || it[0] === 'set') jzifyError('class getters/setters are not supported — jz objects have no accessors')
     if (it[0] === 'static') jzifyError('`static` class members are not supported yet')
     jzifyError(`unsupported class member ${JSON.stringify(it).slice(0, 60)}`)
   }
+  const superMethods = heritage == null ? new Set() : new Set([
+    ...collectSuperMethodCalls(ctorBody),
+    ...fields.flatMap(([, init]) => init == null ? [] : [...collectSuperMethodCalls(init)]),
+    ...methods.flatMap(([, , mbody]) => [...collectSuperMethodCalls(mbody)])
+  ])
+  if (heritage != null) {
+    const dummySuperVars = new Map([...superMethods].map((k, i) => [k, `super_${i}`]))
+    const unsupportedSuperProp = node => node != null && hasSuperProp(rewriteSuperMethodCalls(node, dummySuperVars))
+    if (
+      unsupportedSuperProp(ctorBody) ||
+      fields.some(([, init]) => unsupportedSuperProp(init)) ||
+      methods.some(([, , mbody]) => unsupportedSuperProp(mbody))
+    )
+      jzifyError('`super` property access is not supported yet')
+  }
   const self = `self${classIdx++}`
   const UNDEF = []                                  // jessie's node for `undefined`
-  // A class member body from jessie is a bare statement / `;`-sequence — wrap it
-  // in a `{}` block so the `=>` handler treats it as a function body, not an
-  // expression (an unwrapped `;`-seq arrow body produces malformed IR).
-  const block = b => Array.isArray(b) && b[0] === '{}' ? b : ['{}', b]
-  const usesThis = n => n === 'this' || (Array.isArray(n) && n[0] !== 'function' && n[0] !== 'class' && n.some(usesThis))
   // Object literal: every declared field (its initializer inline when it doesn't
   // touch `this`, else `undefined` and assigned below), every method as its
   // self-capturing arrow. Declaring all fields up front fixes the object shape.
@@ -433,10 +767,39 @@ function lowerClass(name, heritage, body) {
   for (const [mname, mparams, mbody] of methods)
     litProps.push([':', mname, transform(['=>', mparams ?? ['()', null], block(renameThis(mbody, self))])])
   const lit = ['{}', litProps.length === 0 ? null : litProps.length === 1 ? litProps[0] : [',', ...litProps]]
-  const stmts = [['let', ['=', self, lit]]]
+  let params = ctorParams ?? ['()', null]
+  const dynamicBase = heritage != null && typeof heritage !== 'string'
+  const baseRef = heritage == null ? null : dynamicBase ? `base${classBaseIdx++}` : heritage
+  const stmts = []
+  if (heritage != null) {
+    const split = splitCtorSuper(ctorBody)
+    ctorBody = split.body
+    const defaultArgs = ctorParams == null
+      ? Array.from({ length: DEFAULT_DERIVED_CTOR_ARITY }, (_, i) => `superArg${classIdx}_${i}`)
+      : null
+    const baseArgs = split.args ?? (defaultArgs ? [defaultArgs.length === 1 ? defaultArgs[0] : [',', ...defaultArgs]] : paramList(ctorParams))
+    stmts.push(['let', ['=', self, ['()', baseRef, ...baseArgs.map(transform)]]])
+    const superMethodVars = new Map()
+    let superIdx = 0
+    for (const mname of superMethods) {
+      const v = `super${classIdx}_${superIdx++}`
+      superMethodVars.set(mname, v)
+      stmts.push(['let', ['=', v, ['.', self, mname]]])
+    }
+    for (const [fname, init] of fields)
+      stmts.push(['=', ['.', self, fname], init != null ? transform(renameThis(rewriteSuperMethodCalls(init, superMethodVars), self)) : UNDEF])
+    for (const [mname, mparams, mbody] of methods)
+      stmts.push(['=', ['.', self, mname], transform(['=>', mparams ?? ['()', null], block(renameThis(rewriteSuperMethodCalls(mbody, superMethodVars), self))])])
+    ctorBody = rewriteSuperMethodCalls(ctorBody, superMethodVars)
+    if (defaultArgs) params = ['()', defaultArgs.length === 1 ? defaultArgs[0] : [',', ...defaultArgs]]
+  } else {
+    stmts.push(['let', ['=', self, lit]])
+  }
   // `this`-dependent field initializers run, in declaration order, before the ctor.
-  for (const [fname, init] of deferred)
-    stmts.push(['=', ['.', self, fname], transform(renameThis(init, self))])
+  if (heritage == null) {
+    for (const [fname, init] of deferred)
+      stmts.push(['=', ['.', self, fname], transform(renameThis(init, self))])
+  }
   if (ctorBody != null) {
     let cb = transform(renameThis(ctorBody, self))
     if (Array.isArray(cb) && cb[0] === '{}') cb = cb[1]
@@ -444,15 +807,43 @@ function lowerClass(name, heritage, body) {
     else if (cb != null) stmts.push(cb)
   }
   stmts.push(['return', self])
-  return ['=>', arrowParams(ctorParams ?? ['()', null]), ['{}', [';', ...stmts]]]
+  const factory = ['=>', arrowParams(params), ['{}', [';', ...stmts]]]
+  if (!dynamicBase && statics.length === 0) return factory
+
+  const cls = name || `class${staticClassIdx++}`
+  const staticStmts = []
+  if (dynamicBase) staticStmts.push(['let', ['=', baseRef, transform(heritage)]])
+  staticStmts.push(['let', ['=', cls, factory]])
+  for (const [sname, value, isMethod] of statics) {
+    const rhs = isMethod
+      ? transform(['=>', value[1], block(renameThis(value[2], cls))])
+      : value == null ? UNDEF : transform(renameThis(value, cls))
+    staticStmts.push(['=', ['.', cls, sname], rhs])
+  }
+  staticStmts.push(['return', cls])
+  return ['()', ['()', ['=>', null, ['{}', [';', ...staticStmts]]]], null]
+}
+
+// Array(a, b, …) / new Array(a, b, …) → array literal [a, b, …]; Array() → [].
+// The single-argument Array(n) is a length constructor (n holes), not a
+// literal — return null there so the caller keeps it as a constructor call.
+function lowerArrayConstructor(arg) {
+  if (arg == null) return ['[]', null]
+  if (Array.isArray(arg) && arg[0] === ',' && arg.length > 2)
+    return ['[]', [',', ...arg.slice(1).map(transform)]]
+  return null
 }
 
 const handlers = {
   // Named IIFE: (function name(p){b})(a) → let name = arrow; name(a)
   '()'(callee, ...rest) {
+    if (callee === 'Array') {
+      const lit = lowerArrayConstructor(rest[0])
+      if (lit) return lit
+    }
     if (Array.isArray(callee) && callee[0] === '()' && Array.isArray(callee[1]) && callee[1][0] === 'function' && callee[1][1]) {
       const [, name, params, body] = callee[1]
-      const [p2, b2] = lowerArguments(params, body)
+      const [p2, b2] = lowerArguments(params, functionBodyBlock(body))
       return [';', ['let', ['=', name, ['=>', arrowParams(p2), wrapArrowBody(b2)]]], ['()', name, ...rest.map(transform)]]
     }
   },
@@ -461,7 +852,7 @@ const handlers = {
   // bound inside body per ES spec: `function f(){...f...}` → `(()=>{let f;f=arrow;return f})()`.
   // Statement-form named functions are hoisted by transformScope before reaching here.
   'function'(name, params, body) {
-    const [p2, b2] = lowerArguments(params, body)
+    const [p2, b2] = lowerArguments(params, functionBodyBlock(body))
     const arrow = ['=>', p2, wrapArrowBody(b2)]
     if (name) {
       return ['()', ['()', ['=>', null, ['{}', [';',
@@ -474,7 +865,21 @@ const handlers = {
   },
 
   '=>'(params, body) {
-    const [p2, b2] = lowerArguments(params, body)
+    // The subscript parser elides the `[';', stmt, null]` wrapper inside an
+    // arrow's `{` block when the block holds a single statement — the result
+    // `['{}', stmt]` is syntactically identical to an object-literal shape, and
+    // downstream `{}` handlers can no longer tell them apart. JS grammar makes
+    // it unambiguous: `=>` followed by `{` is always a block (use `=> ({...})`
+    // for an object return), so coerce every single-statement body to the
+    // canonical `['{}', [';', stmt]]` block form — `;`-wrapped, never bare.
+    let b = body
+    if (Array.isArray(b) && b[0] === '{}' && b.length === 2) {
+      const inner = b[1]
+      if (inner != null && !(Array.isArray(inner) && inner[0] === ';')) {
+        b = ['{}', [';', inner]]
+      }
+    }
+    const [p2, b2] = lowerArguments(params, b)
     return ['=>', p2, transform(b2)]
   },
 
@@ -490,60 +895,77 @@ const handlers = {
     return ['let', ...args.map(transform)]
   },
 
+  ':'(label, body) {
+    if (typeof label === 'string' && Array.isArray(body) && LABEL_BODY_OPS.has(body[0]))
+      return ['label', label, transform(body)]
+  },
+
   '='(lhs, rhs) {
-    // Chained property assignment: a.x = a.y = v → a.y = v; a.x = v
-    if (Array.isArray(lhs) && lhs[0] === '.' && Array.isArray(rhs) && rhs[0] === '=') {
-      const targets = []
-      let cur = ['=', lhs, rhs]
-      while (Array.isArray(cur) && cur[0] === '=') { targets.push(cur[1]); cur = cur[2] }
-      const val = transform(cur)
-      const stmts = []
-      for (let i = targets.length - 1; i >= 0; i--) stmts.push(['=', transform(targets[i]), val])
-      return stmts.length === 1 ? stmts[0] : [';', ...stmts]
-    }
+    if (isDestructurePat(lhs)) return ['=', transformPattern(lhs), transform(rhs)]
   },
 
   'switch'(disc, ...cases) {
     const clean = cases.map(c => {
       if (c[0] === 'case' && Array.isArray(c[2]) && c[2][0] === ';') {
         const body = c[2].slice(1).filter(s => typeof s !== 'number')
-        return ['case', c[1], body.length === 1 ? body[0] : [';', ...body]]
+        const stripped = stripTerminalSwitchBreak(body.length === 1 ? body[0] : [';', ...body])
+        return ['case', c[1], stripped]
       }
       if (c[0] === 'default' && Array.isArray(c[1]) && c[1][0] === ';') {
         const body = c[1].slice(1).filter(s => s != null && typeof s !== 'number')
-        return ['default', body.length === 1 ? body[0] : [';', ...body]]
+        const stripped = stripTerminalSwitchBreak(body.length === 1 ? body[0] : [';', ...body])
+        return ['default', stripped]
       }
+      if (c[0] === 'case') return ['case', c[1], stripTerminalSwitchBreak(c[2])]
+      if (c[0] === 'default') return ['default', stripTerminalSwitchBreak(c[1])]
       return c
     })
     return transformSwitch(disc, clean)
   },
 
-  // == → ===, != → !== (with prototype identity folding)
-  '=='(a, b) { return isProto(a) || isProto(b) ? 1 : ['===', transform(a), transform(b)] },
-  '!='(a, b) { return isProto(a) || isProto(b) ? 0 : ['!==', transform(a), transform(b)] },
+  // Equality keeps the JS loose/strict distinction (jz core now lowers both):
+  // `==`/`!=` stay loose, `===`/`!==` stay strict. A comparison against a prototype
+  // object (e.g. `x.constructor === Object`) folds to a boolean — jz has no
+  // prototype objects, so identity against one is decided statically.
+  '=='(a, b) { return isProto(a) || isProto(b) ? 1 : ['==', transform(a), transform(b)] },
+  '!='(a, b) { return isProto(a) || isProto(b) ? 0 : ['!=', transform(a), transform(b)] },
   '==='(a, b) { if (isProto(a) || isProto(b)) return 1 },
   '!=='(a, b) { if (isProto(a) || isProto(b)) return 0 },
 
   // new → call (keep TypedArrays)
   'new'(ctor, ...cargs) {
-    if (Array.isArray(ctor) && ctor[0] === '()' && Array.isArray(ctor[1]) && ctor[1][0] === '.') {
-      return ['()', ['.', transform(['new', ctor[1][1]]), ctor[1][2]], ...ctor.slice(2).map(transform)]
+    if (Array.isArray(ctor) && ctor[0] === '()' && ctor[1] === 'Array') {
+      const lit = lowerArrayConstructor(ctor[2])
+      if (lit) return lit
     }
     const name = typeof ctor === 'string' ? ctor : (Array.isArray(ctor) && ctor[0] === '()' ? ctor[1] : null)
-    if (typeof name === 'string' && (TYPED_ARRAYS.has(name) || name === 'Array')) return ['new', transform(ctor), ...cargs.map(transform)]
+    if (typeof name === 'string' && (TYPED_ARRAYS.has(name) || name === 'Array' || name === 'RegExp')) return ['new', transform(ctor), ...cargs.map(transform)]
     if (Array.isArray(ctor) && ctor[0] === '()') return transform(ctor)
     // `new C(a)` → `C(a)`; `new C` (no parens) → `C()` — a 2-element `['()', X]`
     // is grouping parens, so a no-arg call needs the explicit `null` arg slot.
     return ['()', transform(ctor), ...(cargs.length ? cargs.map(transform) : [null])]
   },
 
-  // instanceof → typeof / Array.isArray (jzify allows what strict mode prohibits)
+  // instanceof → typeof / Array.isArray / __is_* helpers. jzify lets us preserve
+  // constructor identity that strict-mode `instanceof` discards — Map, Set, and
+  // TypedArrays get dedicated typed predicates (__is_map / __is_set / __is_typed)
+  // that both compile to a runtime __ptr_type check and feed extractRefinements
+  // for downstream method-dispatch elision (e.g. `if (x instanceof Map) x.has(k)`
+  // resolves to __map_has, not the default __set_has fallback). Date / RegExp /
+  // Object stay on the weak typeof-object lowering — they share PTR.OBJECT and
+  // the JS runtime offers no cheaper discrimination.
   'instanceof'(val, ctor) {
     const t = transform(val)
     const name = typeof ctor === 'string' ? ctor : (Array.isArray(ctor) && ctor[0] === '()' ? ctor[1] : null)
+    // Static fold: literal shape of LHS already discriminates against the constructor.
+    const fold = staticInstanceofFold(val, name)
+    if (fold != null) return [null, fold]
     if (name === 'Array') return ['()', ['.', 'Array', 'isArray'], t]
-    if (name === 'Object') return ['===', ['typeof', t], [null, 'object']]
-    if (typeof name === 'string' && TYPED_ARRAYS.has(name)) return ['===', ['typeof', t], [null, 'object']]
+    if (name === 'Map') return ['()', '__is_map', t]
+    if (name === 'Set') return ['()', '__is_set', t]
+    if (typeof name === 'string' && TYPED_ARRAYS.has(name) && name !== 'ArrayBuffer' && name !== 'DataView')
+      return ['()', '__is_typed', t]
+    // Object / ArrayBuffer / DataView / RegExp / Date / unknown: weak typeof-object check.
     return ['===', ['typeof', t], [null, 'object']]
   },
 
@@ -557,8 +979,27 @@ const handlers = {
       ['while', ['||', flag, transform(cond)], ['{}', [';', ['=', flag, [null, false]], transform(body)]]]]
   },
 
-  // Block body: recurse as scope for hoisting
-  '{}'(...args) { return ['{}', ...args.map(a => transformScope(a) ?? a)] },
+  // Block body: recurse as scope for hoisting. transformScope reduces a single-statement
+  // sequence to its bare element; if the input WAS block-shaped (`;` list or a single
+  // statement op), we re-wrap the collapsed result in `[';', ...]` so prepare.js keeps
+  // routing the `{}` through the block branch instead of mistaking it for `{ expr }`.
+  '{}'(...args) {
+    const loweredObject = lowerObjectLiteralThis(args)
+    if (loweredObject) return loweredObject
+
+    return ['{}', ...args.map((a, i) => {
+      const t = transformScope(a) ?? a
+      if (i !== 0 || a == null) return t
+      const blockIn = Array.isArray(a) && JZ_BLOCK_OPS.has(a[0])
+      if (!blockIn || t == null) return t
+      // transformScope collapses a single-statement `;`-list to its bare element;
+      // re-wrap so the block always stays `['{}', [';', ...]]`. The `;` is the
+      // only reliable block marker — a bare statement op can desugar to an
+      // expression op downstream (postfix `c++` → `['-', ...]`) and lose its
+      // block identity, leaving `['{}', expr]` mistakable for an object literal.
+      return Array.isArray(t) && t[0] === ';' ? t : [';', t]
+    })]
+  },
 
   // Export: recurse into exported declaration. Statement-form `export function name`
   // and `export default function name` must be hoisted as const-arrows — otherwise
@@ -589,7 +1030,10 @@ function transform(node) {
   const [op, ...args] = node
   if (op == null) return node
   const h = handlers[op]
-  return (h && h(...args)) ?? (h ? [op, ...args.map(transform)] : [op, ...args.map(transform)])
+  // A handler that returns nullish (including no `return`) means "no rewrite at
+  // this node" — fall through to a generic recurse. `??` (not `||`) so handlers
+  // like `'==='` can legitimately return `0`.
+  return (h && h(...args)) ?? [op, ...args.map(transform)]
 }
 
 // Esbuild emits a small ESM helper:
@@ -611,16 +1055,16 @@ function foldStaticExportHelpers(ast) {
 
   const defPropAliases = new Set()
   for (const stmt of body) {
-    if (Array.isArray(stmt) && stmt[0] === '=' && typeof stmt[1] === 'string' && isObjectDefineProperty(stmt[2]))
-      defPropAliases.add(stmt[1])
+    const b = bindingOf(stmt)
+    if (b && isObjectDefineProperty(b[1])) defPropAliases.add(b[0])
   }
   if (!defPropAliases.size) return ast
 
   const helperNames = new Set()
   for (const stmt of body) {
-    if (Array.isArray(stmt) && stmt[0] === '=' && typeof stmt[1] === 'string' &&
-        Array.isArray(stmt[2]) && stmt[2][0] === '=>' && containsDefinePropertyCall(stmt[2], defPropAliases))
-      helperNames.add(stmt[1])
+    const b = bindingOf(stmt)
+    if (b && Array.isArray(b[1]) && b[1][0] === '=>' && containsDefinePropertyCall(b[1], defPropAliases))
+      helperNames.add(b[0])
   }
   if (!helperNames.size) return ast
 
@@ -640,6 +1084,210 @@ function foldStaticExportHelpers(ast) {
   return rewritten.length === 0 ? null : rewritten.length === 1 ? rewritten[0] : [';', ...rewritten]
 }
 
+// Esbuild's CommonJS/ESM interop helpers alias Object reflection built-ins into
+// locals (`var __create = Object.create`, `var __getOwnPropNames =
+// Object.getOwnPropertyNames`, ...). jz deliberately does not expose those
+// built-ins as first-class function values, but the helpers are static enough to
+// lower back to the supported direct calls and module reads.
+function foldStaticBundlerHelpers(ast) {
+  const body = astSeq(ast)
+  if (!body) return ast
+  const binds = body.map(bindingOf)   // [name, init] | null, index-aligned with body
+
+  // Local aliases of Object reflection built-ins: name -> canonical built-in.
+  // esbuild's interop preamble always emits these (`var __defProp =
+  // Object.defineProperty`, ...); their absence proves the input is not a
+  // bundle, so the fold stays a strict no-op rather than guessing.
+  const aliases = new Map()
+  for (const b of binds) {
+    const key = b && objectBuiltinKey(b[1])
+    if (key) aliases.set(b[0], key)
+  }
+  if (!aliases.size) return ast
+
+  // __copyProps: an arrow driving both aliased getOwnPropertyNames + defineProperty.
+  const copyHelpers = new Set()
+  for (const b of binds)
+    if (b && isArrow(b[1]) &&
+        containsCall(b[1], c => aliases.get(c) === 'Object.getOwnPropertyNames') &&
+        containsCall(b[1], c => aliases.get(c) === 'Object.defineProperty'))
+      copyHelpers.add(b[0])
+
+  // __toESM: an arrow cloning a module behind a prototype, tagging default/__esModule.
+  const interopHelpers = new Set()
+  for (const b of binds)
+    if (b && isArrow(b[1]) &&
+        containsCall(b[1], c => aliases.get(c) === 'Object.create') &&
+        containsCall(b[1], c => aliases.get(c) === 'Object.getPrototypeOf') &&
+        containsCall(b[1], c => copyHelpers.has(c)) &&
+        astSome(b[1], n => n === 'default') && astSome(b[1], n => n === '__esModule'))
+      interopHelpers.add(b[0])
+
+  // Bindings produced by an interop-helper call: name -> wrapped module expression.
+  const interopBindings = new Map()
+  for (const b of binds)
+    if (b && Array.isArray(b[1]) && b[1][0] === '()' && interopHelpers.has(b[1][1])) {
+      const args = callArgs(b[1].slice(2))
+      if (args.length) interopBindings.set(b[0], args[0])
+    }
+
+  let out = body.map(stmt => rewriteBundlerAliases(stmt, aliases, interopBindings))
+  if (interopBindings.size) out = out.map(stmt => replaceInteropReads(stmt, interopBindings))
+  out = out.map(stmt => rewriteBundlerAliases(stmt, aliases, interopBindings)).filter(s => s != null)
+
+  // Drop synthetic alias/helper bindings nothing references after rewriting.
+  const synthetic = n => aliases.has(n) || copyHelpers.has(n) || interopHelpers.has(n) || interopBindings.has(n)
+  const live = new Set()
+  for (const stmt of out) {
+    const b = bindingOf(stmt)
+    if (!(b && synthetic(b[0]))) collectRefs(stmt, live)
+  }
+  out = out.filter(stmt => {
+    const b = bindingOf(stmt)
+    return !(b && synthetic(b[0]) && !live.has(b[0]))
+  })
+
+  return out.length === 0 ? null : out.length === 1 ? out[0] : [';', ...out]
+}
+
+const isArrow = node => Array.isArray(node) && node[0] === '=>'
+
+const OBJECT_BUILTINS = new Set(['create', 'getPrototypeOf', 'getOwnPropertyNames', 'getOwnPropertyDescriptor', 'defineProperty'])
+
+// Canonical name of the Object reflection built-in `node` references, or null.
+function objectBuiltinKey(node) {
+  if (!Array.isArray(node) || node[0] !== '.') return null
+  if (node[1] === 'Object' && OBJECT_BUILTINS.has(node[2])) return 'Object.' + node[2]
+  return isObjectHasOwnPropertyRef(node) ? 'Object.prototype.hasOwnProperty' : null
+}
+
+// Deep `some` over AST children (skips the op slot, so op names never match).
+function astSome(node, pred) {
+  if (pred(node)) return true
+  if (!Array.isArray(node)) return false
+  for (let i = 1; i < node.length; i++) if (astSome(node[i], pred)) return true
+  return false
+}
+
+// Does `node` contain a `()` call whose string callee satisfies `ok`?
+const containsCall = (node, ok) =>
+  astSome(node, n => Array.isArray(n) && n[0] === '()' && typeof n[1] === 'string' && ok(n[1]))
+
+function rewriteBundlerAliases(node, aliases, interopBindings) {
+  if (!Array.isArray(node)) return node
+  const rec = n => rewriteBundlerAliases(n, aliases, interopBindings)
+
+  if (node[0] === ';') {
+    const out = [';']
+    for (let i = 1; i < node.length; i++) {
+      const child = rec(node[i])
+      if (child != null) out.push(child)
+    }
+    return out.length === 1 ? null : out.length === 2 ? out[1] : out
+  }
+  if (node[0] === '{}' && node.length === 2) {
+    const wasBlock = Array.isArray(node[1]) && JZ_BLOCK_OPS.has(node[1][0])
+    const inner = rec(node[1])
+    if (!wasBlock || inner == null) return ['{}', inner]
+    const stayed = Array.isArray(inner) && JZ_BLOCK_OPS.has(inner[0])
+    return ['{}', stayed ? inner : [';', inner]]
+  }
+
+  if (node[0] === '()') {
+    const callee = node[1]
+    const args = callArgs(node.slice(2))
+
+    if (typeof callee === 'string') {
+      const key = aliases.get(callee)
+      if (key === 'Object.defineProperty') {
+        const define = staticDefineProperty(args)
+        if (define !== undefined) return define
+      }
+      if (key === 'Object.getOwnPropertyNames' || key === 'Object.create') {
+        if (key === 'Object.create' && isGetPrototypeOfCall(args[0], aliases)) return ['{}', null]
+        return ['()', key, ...args.map(rec)]
+      }
+    }
+    // `__hasOwnProp.call(o, k)` -> `o.hasOwnProperty(k)`.
+    if (Array.isArray(callee) && callee[0] === '.' && callee[2] === 'call' && args.length >= 2 &&
+        typeof callee[1] === 'string' && aliases.get(callee[1]) === 'Object.prototype.hasOwnProperty')
+      return ['()', ['.', rec(args[0]), 'hasOwnProperty'], rec(args[1])]
+    // `(0, fn)(...)` comma-call resolving to an interop module read.
+    const seqCall = commaZeroCall(callee, interopBindings)
+    if (seqCall) return ['()', seqCall, ...args.map(rec)]
+  }
+
+  if (node[0] === '.' || node[0] === '?.') return [node[0], rec(node[1]), node[2]]
+  if (node[0] === ':') return [node[0], node[1], rec(node[2])]
+  return node.map((part, i) => i === 0 ? part : rec(part))
+}
+
+function replaceInteropReads(node, bindings) {
+  if (typeof node === 'string' && bindings.has(node)) return cloneAst(bindings.get(node))
+  if (!Array.isArray(node)) return node
+  if (node[0] === '=' && typeof node[1] === 'string') return ['=', node[1], replaceInteropReads(node[2], bindings)]
+  if (node[0] === 'let' || node[0] === 'const' || node[0] === 'var')
+    return [node[0], ...node.slice(1).map(decl =>
+      Array.isArray(decl) && decl[0] === '=' ? ['=', decl[1], replaceInteropReads(decl[2], bindings)] : decl)]
+  if ((node[0] === '.' || node[0] === '?.') && typeof node[1] === 'string' && typeof node[2] === 'string' && bindings.has(node[1])) {
+    const mod = cloneAst(bindings.get(node[1]))
+    return node[2] === 'default' ? mod : [node[0], mod, node[2]]
+  }
+  if (node[0] === ':') return [node[0], node[1], replaceInteropReads(node[2], bindings)]
+  return node.map((part, i) => i === 0 ? part : replaceInteropReads(part, bindings))
+}
+
+function isGetPrototypeOfCall(node, aliases) {
+  if (!Array.isArray(node) || node[0] !== '()') return false
+  const callee = node[1]
+  return (typeof callee === 'string' && aliases.get(callee) === 'Object.getPrototypeOf') ||
+    objectBuiltinKey(callee) === 'Object.getPrototypeOf'
+}
+
+function commaZeroCall(callee, bindings) {
+  if (!Array.isArray(callee) || callee[0] !== '()' || !Array.isArray(callee[1]) || callee[1][0] !== ',') return null
+  const parts = callee[1].slice(1)
+  if (parts.length !== 2 || !isZeroLiteral(parts[0])) return null
+  const fn = replaceInteropReads(parts[1], bindings)
+  return fn === parts[1] ? null : fn
+}
+
+// `defProp(obj, "key", descriptor)` -> `obj.key = value`; null drops `__esModule`.
+function staticDefineProperty(args) {
+  if (args.length < 3) return undefined
+  const [obj, keyExpr, desc] = args
+  const key = stringLiteral(keyExpr)
+  const props = objectProps(desc)
+  if (typeof key !== 'string' || !props) return undefined
+  if (key === '__esModule') return null
+  const prop = name => props.find(p => Array.isArray(p) && p[0] === ':' && p[1] === name)?.[2]
+  const value = prop('value')
+  if (value !== undefined) return ['=', ['.', obj, key], value]
+  const got = getterReturnExpr(prop('get'))
+  return got !== null ? ['=', ['.', obj, key], got] : undefined
+}
+
+function stringLiteral(node) {
+  return Array.isArray(node) && node[0] == null && typeof node[1] === 'string' ? node[1] : null
+}
+
+// Identifier references in `node`, excluding declaration names, member property
+// names and object keys — enough to decide whether a synthetic binding is live.
+function collectRefs(node, out) {
+  if (typeof node === 'string') return void out.add(node)
+  if (!Array.isArray(node)) return
+  if (node[0] === 'let' || node[0] === 'const' || node[0] === 'var') {
+    for (let i = 1; i < node.length; i++)
+      if (Array.isArray(node[i]) && node[i][0] === '=') collectRefs(node[i][2], out)
+  } else if ((node[0] === '.' || node[0] === '?.') && typeof node[2] === 'string') {
+    collectRefs(node[1], out)
+  } else if (node[0] === ':') {
+    collectRefs(node[2], out)
+  } else {
+    for (let i = 1; i < node.length; i++) collectRefs(node[i], out)
+  }
+}
+
 function astSeq(ast) {
   if (!Array.isArray(ast)) return null
   return ast[0] === ';' ? ast.slice(1).filter(Boolean) : [ast]
@@ -649,12 +1297,28 @@ function isObjectDefineProperty(node) {
   return Array.isArray(node) && node[0] === '.' && node[1] === 'Object' && node[2] === 'defineProperty'
 }
 
+/** Unwrap an esbuild module binding to `[name, init]`. After hoistVars, a binding
+ *  reaches this pass either split into a bare `['=', name, init]` (RHS hoisted out
+ *  as a separate `let name;`) or kept as a single `['let', ['=', name, init]]` decl
+ *  (arrow RHS — see the `;` handler in hoistVars). The fold keys on name/init,
+ *  so it must see through both shapes. */
+function bindingOf(stmt) {
+  if (!Array.isArray(stmt)) return null
+  if (stmt[0] === '=' && typeof stmt[1] === 'string') return [stmt[1], stmt[2]]
+  if ((stmt[0] === 'let' || stmt[0] === 'const' || stmt[0] === 'var') && stmt.length === 2 &&
+      Array.isArray(stmt[1]) && stmt[1][0] === '=' && typeof stmt[1][1] === 'string')
+    return [stmt[1][1], stmt[1][2]]
+  return null
+}
+
 function isDefPropAliasAssign(stmt, aliases) {
-  return Array.isArray(stmt) && stmt[0] === '=' && aliases.has(stmt[1]) && isObjectDefineProperty(stmt[2])
+  const b = bindingOf(stmt)
+  return b != null && aliases.has(b[0]) && isObjectDefineProperty(b[1])
 }
 
 function isExportHelperAssign(stmt, helpers) {
-  return Array.isArray(stmt) && stmt[0] === '=' && helpers.has(stmt[1])
+  const b = bindingOf(stmt)
+  return b != null && helpers.has(b[0])
 }
 
 function containsDefinePropertyCall(node, aliases) {
@@ -699,6 +1363,8 @@ function getterReturnExpr(node) {
   if (params.length !== 0) return null
   const body = node[2]
   if (Array.isArray(body) && body[0] === '{}' && Array.isArray(body[1]) && body[1][0] === 'return') return body[1][1]
+  if (Array.isArray(body) && body[0] === '{}' && Array.isArray(body[1]) && body[1][0] === ';' &&
+      Array.isArray(body[1][1]) && body[1][1][0] === 'return') return body[1][1][1]
   if (Array.isArray(body) && body[0] === 'return') return body[1]
   return body
 }
@@ -713,202 +1379,175 @@ function replaceStaticExportReads(node, rewrites) {
   return node.map((part, i) => i === 0 ? part : replaceStaticExportReads(part, rewrites))
 }
 
+function canonicalizeObjectIdioms(node) {
+  if (node == null || typeof node !== 'object' || !Array.isArray(node)) return node
+
+  const out = node.map((part, i) => i === 0 ? part : canonicalizeObjectIdioms(part))
+
+  const hasOwnCall = objectHasOwnPropertyCall(out)
+  if (hasOwnCall) return ['()', ['.', hasOwnCall.obj, 'hasOwnProperty'], hasOwnCall.key]
+
+  const mapString = arrayMapStringCallback(out)
+  if (mapString) return mapString
+
+  if (out[0] === '&&') {
+    const leftCtor = constructorIsObject(out[1])
+    const rightKeys = objectKeysLengthZero(out[2])
+    if (leftCtor && rightKeys && astEqual(leftCtor.obj, rightKeys.obj)) return out[2]
+
+    const leftKeys = objectKeysLengthZero(out[1])
+    const rightCtor = constructorIsObject(out[2])
+    if (leftKeys && rightCtor && astEqual(leftKeys.obj, rightCtor.obj)) return out[1]
+  }
+
+  return out
+}
+
+function arrayMapStringCallback(node) {
+  if (!Array.isArray(node) || node[0] !== '()') return null
+  const callee = node[1]
+  if (!Array.isArray(callee) || callee[0] !== '.' || callee[2] !== 'map') return null
+  const args = callArgs(node.slice(2))
+  if (args.length !== 1 || args[0] !== 'String') return null
+  return ['()', callee, ['=>', 'value', ['()', 'String', 'value']]]
+}
+
+function objectHasOwnPropertyCall(node) {
+  if (!Array.isArray(node) || node[0] !== '()') return null
+  const callee = node[1]
+  if (!Array.isArray(callee) || callee[0] !== '.' || callee[2] !== 'call') return null
+  if (!isObjectHasOwnPropertyRef(callee[1])) return null
+  const args = callArgs(node.slice(2))
+  if (args.length < 2) return null
+  return { obj: args[0], key: args[1] }
+}
+
+function isObjectHasOwnPropertyRef(node) {
+  if (!Array.isArray(node) || node[0] !== '.' || node[2] !== 'hasOwnProperty') return false
+  if (node[1] === 'Object') return true
+  return Array.isArray(node[1]) && node[1][0] === '.' && node[1][1] === 'Object' && node[1][2] === 'prototype'
+}
+
+function constructorIsObject(node) {
+  if (!Array.isArray(node) || (node[0] !== '===' && node[0] !== '==')) return null
+  const left = constructorReceiver(node[1])
+  if (left && node[2] === 'Object') return { obj: left }
+  const right = constructorReceiver(node[2])
+  if (right && node[1] === 'Object') return { obj: right }
+  return null
+}
+
+function constructorReceiver(node) {
+  return Array.isArray(node) && node[0] === '.' && node[2] === 'constructor' ? node[1] : null
+}
+
+function objectKeysLengthZero(node) {
+  if (!Array.isArray(node) || (node[0] !== '===' && node[0] !== '==')) return null
+  const left = objectKeysLengthReceiver(node[1])
+  if (left && isZeroLiteral(node[2])) return { obj: left }
+  const right = objectKeysLengthReceiver(node[2])
+  if (right && isZeroLiteral(node[1])) return { obj: right }
+  return null
+}
+
+function objectKeysLengthReceiver(node) {
+  if (!Array.isArray(node) || node[0] !== '.' || node[2] !== 'length') return null
+  const call = node[1]
+  if (!Array.isArray(call) || call[0] !== '()') return null
+  const callee = call[1]
+  if (!Array.isArray(callee) || callee[0] !== '.' || callee[1] !== 'Object' || callee[2] !== 'keys') return null
+  const args = callArgs(call.slice(2))
+  return args.length === 1 ? args[0] : null
+}
+
+function isZeroLiteral(node) {
+  return Array.isArray(node) && node[0] == null && node[1] === 0
+}
+
+function astEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b)
+}
+
 function cloneAst(node) {
   if (node == null || typeof node !== 'object') return node
   if (!Array.isArray(node)) return node
   return node.map(cloneAst)
 }
 
+function stripTerminalSwitchBreak(body) {
+  if (!Array.isArray(body)) return body
+  if (body[0] === 'break') return null
+  if (body[0] === '{}') {
+    const inner = stripTerminalSwitchBreak(body[1])
+    if (inner == null) return ['{}', [';']]
+    return ['{}', Array.isArray(inner) && inner[0] === ';' ? inner : [';', inner]]
+  }
+  if (body[0] !== ';') return body
+
+  const stmts = body.slice(1)
+  if (Array.isArray(stmts.at(-1)) && stmts.at(-1)[0] === 'break') stmts.pop()
+  return stmts.length === 0 ? null : stmts.length === 1 ? stmts[0] : [';', ...stmts]
+}
+
+const SWITCH_BREAK_BOUNDARIES = new Set(['for', 'for-in', 'for-of', 'while', 'do', 'switch', '=>', 'function', 'class'])
+
+function hasOwnSwitchBreak(node) {
+  if (!Array.isArray(node)) return false
+  if (node[0] === 'break') return true
+  if (SWITCH_BREAK_BOUNDARIES.has(node[0])) return false
+  for (let i = 1; i < node.length; i++) if (hasOwnSwitchBreak(node[i])) return true
+  return false
+}
+
+function rewriteSwitchBreaks(node, flag) {
+  if (!Array.isArray(node)) return node
+  const op = node[0]
+  if (op === 'break') return ['=', flag, [null, true]]
+  if (SWITCH_BREAK_BOUNDARIES.has(op)) return node
+
+  if (op === ';') {
+    const out = []
+    const stmts = node.slice(1)
+    for (let i = 0; i < stmts.length; i++) {
+      const stmt = stmts[i]
+      out.push(rewriteSwitchBreaks(stmt, flag))
+      if (hasOwnSwitchBreak(stmt) && i < stmts.length - 1) {
+        const tail = rewriteSwitchBreaks([';', ...stmts.slice(i + 1)], flag)
+        out.push(['if', ['!', flag], tail])
+        break
+      }
+    }
+    return out.length === 0 ? null : out.length === 1 ? out[0] : [';', ...out]
+  }
+
+  return node.map((part, i) => i === 0 ? part : rewriteSwitchBreaks(part, flag))
+}
+
 /** Transform switch statement to if/else chain. */
 let swIdx = 0
 function transformSwitch(discriminant, cases) {
   const disc = transform(discriminant)
   const tmp = `\uE000sw${swIdx++}`
+  const needsBreakFlag = cases.some(c => hasOwnSwitchBreak(c[0] === 'case' ? c[2] : c[1]))
+  const brk = needsBreakFlag ? `\uE000swbrk${swIdx++}` : null
 
   // Collect case/default
   const stmts = [['let', ['=', tmp, disc]]]
+  if (brk) stmts.push(['let', ['=', brk, [null, false]]])
   let chain = null
 
   for (let i = cases.length - 1; i >= 0; i--) {
     const c = cases[i]
     if (c[0] === 'default') {
-      chain = transform(c[1])
+      const body = transform(c[1])
+      chain = brk ? rewriteSwitchBreaks(body, brk) : body
     } else if (c[0] === 'case') {
       const cond = ['===', tmp, transform(c[1])]
       const body = transform(c[2])
-      chain = chain != null ? ['if', cond, body, chain] : ['if', cond, body]
+      const lowered = brk ? rewriteSwitchBreaks(body, brk) : body
+      chain = chain != null ? ['if', cond, lowered, chain] : ['if', cond, lowered]
     }
   }
   if (chain) stmts.push(chain)
   return [';', ...stmts]
 }
-
-// === AST → jz source codegen ===
-
-const INDENT = '  '
-const prec = { '=': 1, '+=': 1, '-=': 1, '*=': 1, '/=': 1, '%=': 1, '&=': 1, '|=': 1, '^=': 1, '>>=': 1, '<<=': 1, '>>>=': 1, '||=': 1, '&&=': 1,
-  '??': 2, '||': 3, '&&': 4, '|': 5, '^': 6, '&': 7, '===': 8, '!==': 8, '==': 8, '!=': 8,
-  '<': 9, '>': 9, '<=': 9, '>=': 9, '<<': 10, '>>': 10, '>>>': 10,
-  '+': 11, '-': 11, '*': 12, '/': 12, '%': 12, '**': 13 }
-
-/** Wrap statement in { } if not already a block */
-function wrapBlock(node, depth) {
-  if (Array.isArray(node) && node[0] === '{}') return codegen(node, depth)
-  return '{ ' + codegen(node, depth) + '; }'
-}
-
-/** Generate jz source from AST. Enforces semicolons. */
-export function codegen(node, depth = 0) {
-  if (node == null) return ''
-  if (typeof node === 'number') return String(node)
-  if (typeof node === 'bigint') return node + 'n'
-  if (typeof node === 'string') return node
-  if (!Array.isArray(node)) return String(node)
-
-  const [op, ...a] = node
-  const ind = INDENT.repeat(depth), ind1 = INDENT.repeat(depth + 1)
-
-  // Literal: [, value]
-  if (op == null) return typeof a[0] === 'string' ? JSON.stringify(a[0]) : a[0] == null ? 'null' : String(a[0]) + (typeof a[0] === 'bigint' ? 'n' : '')
-
-  // Statements
-  if (op === ';') return a.map(s => codegen(s, depth)).filter(Boolean).join(';\n' + ind) + ';'
-  if (op === '{}') {
-    // Discriminate object literal / destructuring pattern from block.
-    // Object: `:` key-value, `,` of object-pattern items (id / `:` / `...` / `= default`),
-    //         lone string shorthand. Empty `{}` outputs the same string either way.
-    const body = a[0]
-    const isObjItem = (n) => typeof n === 'string' ||
-      (Array.isArray(n) && (n[0] === ':' || n[0] === '...' || n[0] === 'as' ||
-        (n[0] === '=' && typeof n[1] === 'string')))
-    const isObj = body == null ? false
-      : typeof body === 'string' ? true
-      : Array.isArray(body) && (body[0] === ':' || body[0] === '...' || body[0] === 'as' ||
-          (body[0] === ',' && body.slice(1).every(isObjItem)))
-    if (isObj) {
-      if (typeof body === 'string') return '{ ' + body + ' }'
-      if (body[0] === ',') return '{ ' + body.slice(1).map(x => codegen(x)).join(', ') + ' }'
-      return '{ ' + codegen(body) + ' }'
-    }
-    // Block: body is null, a single statement, or [';', ...stmts]
-    const stmts = body == null ? [] : (Array.isArray(body) && body[0] === ';' ? body.slice(1) : [body])
-    const rendered = stmts.map(s => codegen(s, depth + 1)).filter(Boolean).join(';\n' + ind1)
-    return '{\n' + ind1 + rendered + (rendered ? ';' : '') + '\n' + ind + '}'
-  }
-
-  // Declarations
-  if (op === 'let' || op === 'const') return op + ' ' + a.map(d => codegen(d, depth)).join(', ')
-  if (op === 'export') { const inner = codegen(a[0], depth); return inner ? 'export ' + inner : '' }
-  if (op === 'default') return 'default ' + codegen(a[0], depth)
-
-  // Control flow
-  if (op === 'if') {
-    const cond = codegen(a[0]), then = wrapBlock(a[1], depth)
-    return a[2] != null
-      ? 'if (' + cond + ') ' + then + ' else ' + wrapBlock(a[2], depth)
-      : 'if (' + cond + ') ' + then
-  }
-  if (op === 'while') return 'while (' + codegen(a[0]) + ') ' + wrapBlock(a[1], depth)
-  if (op === 'for') {
-    if (a.length === 2) { // ['for', head, body] — subscript shape
-      const [head, body] = a
-      if (Array.isArray(head) && (head[0] === 'of' || head[0] === 'in'))
-        return 'for (' + codegen(head[1]) + ' ' + head[0] + ' ' + codegen(head[2]) + ') ' + wrapBlock(body, depth)
-      // ['let'/'const', ['in'/'of', name, obj]] — subscript wraps var→let around in/of
-      if (Array.isArray(head) && (head[0] === 'let' || head[0] === 'const') && Array.isArray(head[1]) && (head[1][0] === 'in' || head[1][0] === 'of'))
-        return 'for (' + head[0] + ' ' + codegen(head[1][1]) + ' ' + head[1][0] + ' ' + codegen(head[1][2]) + ') ' + wrapBlock(body, depth)
-      // C-style head [';', init, cond, update] is positional — empty slots are valid,
-      // must not flow through the generic `;` joiner (which adds newlines + a trailing `;`).
-      if (Array.isArray(head) && head[0] === ';')
-        return 'for (' + (head[1] == null ? '' : codegen(head[1])) + '; ' + (head[2] == null ? '' : codegen(head[2])) + '; ' + (head[3] == null ? '' : codegen(head[3])) + ') ' + wrapBlock(body, depth)
-      return 'for (' + codegen(head) + ') ' + wrapBlock(body, depth)
-    }
-    return 'for (' + (codegen(a[0]) || '') + '; ' + (codegen(a[1]) || '') + '; ' + (codegen(a[2]) || '') + ') ' + wrapBlock(a[3], depth)
-  }
-  if (op === 'return') return 'return ' + codegen(a[0])
-  if (op === 'throw') return 'throw ' + codegen(a[0])
-  if (op === 'break') return 'break'
-  if (op === 'continue') return 'continue'
-  // catch with optional binding: ['catch', tryBlock, catchBody] or ['catch', tryBlock, paramName, catchBody]
-  if (op === 'catch') {
-    if (a.length === 3) return 'try ' + codegen(a[0], depth) + ' catch (' + a[1] + ') ' + codegen(a[2], depth)
-    return 'try ' + codegen(a[0], depth) + ' catch ' + codegen(a[1], depth)
-  }
-
-  // Arrow
-  if (op === '=>') {
-    // Params: already wrapped in () by parser, or bare name
-    const p = a[0]
-    const params = Array.isArray(p) && p[0] === '()' ? codegen(p) : '(' + codegen(p) + ')'
-    const body = a[1]
-    const isBlock = Array.isArray(body) && (body[0] === '{}' || body[0] === ';' || body[0] === 'return')
-    const bodyStr = Array.isArray(body) && body[0] !== '{}' && isBlock
-      ? '{ ' + codegen(body, depth) + '; }'
-      : codegen(body, depth)
-    return params + ' => ' + bodyStr
-  }
-
-  // Grouping parens / function call
-  if (op === '()') {
-    if (a.length === 1) return '(' + (a[0] == null ? '' : codegen(a[0])) + ')'
-    return codegen(a[0]) + '(' + a.slice(1).map(x => codegen(x)).join(', ') + ')'
-  }
-
-  // Property access
-  if (op === '.') return codegen(a[0]) + '.' + a[1]
-  if (op === '?.') return codegen(a[0]) + '?.' + a[1]
-  if (op === '?.[]') return codegen(a[0]) + '?.[' + codegen(a[1]) + ']'
-  if (op === '?.()') return codegen(a[0]) + '?.(' + a.slice(1).map(x => codegen(x)).join(', ') + ')'
-  if (op === '[]') {
-    // Array literal: ['[]', body] (length 2 → a.length 1). body may be null (empty),
-    // a single element, or a [',', ...items] sequence.
-    if (a.length === 1) {
-      if (a[0] == null) return '[]'
-      const body = a[0]
-      if (Array.isArray(body) && body[0] === ',') return '[' + body.slice(1).map(x => codegen(x)).join(', ') + ']'
-      return '[' + codegen(body) + ']'
-    }
-    // Subscript: ['[]', obj, idx]
-    return codegen(a[0]) + '[' + codegen(a[1]) + ']'
-  }
-  if (op === ':') return codegen(a[0]) + ': ' + codegen(a[1])
-  if (op === 'str') return JSON.stringify(a[0])
-  if (op === '//') return '/' + a[0] + '/' + (a[1] || '')
-
-  // Comma
-  if (op === ',') return a.map(x => codegen(x)).join(', ')
-  // Template literal: alternating string/expr parts. String parts are [null, "str"], expr parts are AST nodes.
-  if (op === '`') return '`' + a.map(p => {
-    if (Array.isArray(p) && p[0] == null && typeof p[1] === 'string') return p[1].replace(/[`\\$]/g, c => '\\' + c)
-    return '${' + codegen(p) + '}'
-  }).join('') + '`'
-
-  // Spread
-  if (op === '...') return '...' + codegen(a[0])
-
-  // Import / export rename
-  if (op === 'import') return 'import ' + codegen(a[0])
-  if (op === 'from') return codegen(a[0]) + ' from ' + codegen(a[1])
-  if (op === 'as') return codegen(a[0]) + ' as ' + codegen(a[1])
-
-  // Unary prefix
-  if (a.length === 1) {
-    if (op === '++' || op === '--') return a[0] == null ? op : op + codegen(a[0])
-    if (op === 'typeof') return 'typeof ' + codegen(a[0])
-    if (op === 'u-') return '-' + codegen(a[0])
-    if (op === 'u+') return '+' + codegen(a[0])
-    return op + codegen(a[0])
-  }
-
-  // Postfix
-  if (a.length === 2 && a[1] === null) return codegen(a[0]) + op
-
-  // Binary
-  if (a.length === 2 && prec[op]) return codegen(a[0]) + ' ' + op + ' ' + codegen(a[1])
-
-  // Ternary
-  if (op === '?' || op === '?:') return codegen(a[0]) + ' ? ' + codegen(a[1]) + ' : ' + codegen(a[2])
-
-  // Fallback
-  return op + '(' + a.map(x => codegen(x)).join(', ') + ')'
-}