jz 0.4.0 → 0.5.1

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(canonicalizeObjectIdioms(transformScope(ast)))
+  return foldStaticBundlerHelpers(foldStaticExportHelpers(canonicalizeObjectIdioms(transformScope(ast))))
 }
 
 /**
@@ -71,16 +74,24 @@ 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
-    const normalizedHead = normalizeForDeclHead(head, names)
+    const normalizedHead = normalizeForDeclHead(head, names) || normalizeForCommaHead(head, names)
     if (normalizedHead) {
       h2 = normalizedHead
     } else if (Array.isArray(head) && head[0] === 'var' && Array.isArray(head[1]) &&
@@ -109,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)]
@@ -141,18 +211,39 @@ function prependDecls(body, names) {
 }
 
 function normalizeForDeclHead(head, names) {
-  if (!Array.isArray(head) || (head[0] !== 'var' && head[0] !== 'let' && head[0] !== 'const') || head.length !== 2) return null
+  if (!Array.isArray(head) || (head[0] !== 'var' && head[0] !== 'let' && head[0] !== 'const')) return null
   const kind = head[0]
-  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)]
+  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)
@@ -163,7 +254,7 @@ function normalizeForDecl(kind, name, names) {
 
 /** 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
@@ -185,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]))
@@ -249,33 +321,109 @@ 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 */
 const isProto = n => Array.isArray(n) && n[0] === '.' && Array.isArray(n[1]) && n[1][0] === '.' && n[1][2] === 'prototype'
 
+/** `obj.M <eq> Ctor.prototype.M` is not a real reference comparison — jz has no
+ *  prototype objects — it asks whether `obj` overrides `M`, which is exactly
+ *  `obj.hasOwnProperty('M')`. Returns that call node when the shape matches
+ *  (a member access `obj.M` against a same-named prototype method), else null. */
+const methodOverrideHasOwn = (a, b) => {
+  const proto = isProto(a) ? a : isProto(b) ? b : null
+  if (!proto) return null
+  const other = proto === a ? b : a
+  if (!Array.isArray(other) || other[0] !== '.' || other[2] !== proto[2]) return null
+  return ['()', ['.', transform(other[1]), 'hasOwnProperty'], [null, proto[2]]]
+}
+
 const TYPED_ARRAYS = new Set(['Float64Array','Float32Array','Int32Array','Uint32Array',
   '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 '=>'.
@@ -373,6 +521,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 ===
 //
@@ -393,10 +545,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]
@@ -413,39 +574,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.
@@ -457,10 +779,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]
@@ -468,15 +819,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)]]
     }
   },
@@ -485,7 +864,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, ['{}', [';',
@@ -498,7 +877,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)]
   },
 
@@ -514,64 +907,69 @@ 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')
-        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')
-        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])]
+      if (c[0] === 'case') return ['case', c[1], normalizeCaseBody(c[2])]
+      if (c[0] === 'default') return ['default', normalizeCaseBody(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)] },
-  '==='(a, b) { if (isProto(a) || isProto(b)) return 1 },
-  '!=='(a, b) { if (isProto(a) || isProto(b)) return 0 },
+  // Equality keeps the JS loose/strict distinction (jz core now lowers both):
+  // `==`/`!=` stay loose, `===`/`!==` stay strict. A comparison against a prototype
+  // object folds to a boolean — jz has no prototype objects, so identity against one
+  // is decided statically. The one exception is `obj.M <eq> Ctor.prototype.M`: that
+  // probes whether `obj` overrides the builtin `M`, so it lowers to a runtime
+  // `obj.hasOwnProperty('M')` (equal ⇒ not overridden, unequal ⇒ overridden).
+  '=='(a, b) { const own = methodOverrideHasOwn(a, b); if (own) return ['!', own]; return isProto(a) || isProto(b) ? 1 : ['==', transform(a), transform(b)] },
+  '!='(a, b) { const own = methodOverrideHasOwn(a, b); if (own) return own; return isProto(a) || isProto(b) ? 0 : ['!=', transform(a), transform(b)] },
+  '==='(a, b) { const own = methodOverrideHasOwn(a, b); if (own) return ['!', own]; if (isProto(a) || isProto(b)) return 1 },
+  '!=='(a, b) { const own = methodOverrideHasOwn(a, b); if (own) return own; 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']]
   },
 
@@ -585,8 +983,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
@@ -642,16 +1059,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
 
@@ -671,6 +1088,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]
@@ -680,12 +1301,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) {
@@ -730,6 +1367,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
 }
@@ -752,6 +1391,9 @@ function canonicalizeObjectIdioms(node) {
   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])
@@ -765,16 +1407,31 @@ function canonicalizeObjectIdioms(node) {
   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 (!Array.isArray(callee[1]) || callee[1][0] !== '.' || callee[1][1] !== 'Object' || callee[1][2] !== 'hasOwnProperty') 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])
@@ -821,41 +1478,103 @@ function cloneAst(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]]
+/** Flatten a switch clause body to a single node, dropping ASI position markers.
+ * Unlike a plain statement list this keeps any `break` intact — transformSwitch
+ * needs the breaks to gate fall-through; it rewrites them to a sticky flag. */
+function normalizeCaseBody(body) {
+  if (!Array.isArray(body) || body[0] !== ';') return body
+  const stmts = body.slice(1).filter(s => s != null && typeof s !== 'number')
+  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]
   }
-  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]
+  return node.map((part, i) => i === 0 ? part : rewriteSwitchBreaks(part, flag))
 }
 
-/** Transform switch statement to if/else chain. */
+/** Transform a switch into structured control flow with faithful fall-through.
+ *
+ * A pure if/else-if chain (the former lowering) can't express fall-through,
+ * stacked labels, or a `default` clause that isn't last \u2014 it ran only the first
+ * matching body. The correct model is two-phase, evaluated once with no goto:
+ *
+ *   1. ENTRY \u2014 compare the discriminant against each `case` label in source
+ *      order; the first `===` match fixes the entry index. No case matches \u2192
+ *      entry = the `default` clause's source index (or past-end if none).
+ *   2. RUN \u2014 walk clauses in source order; `entry <= i` runs clause i, so every
+ *      clause from the entry onward executes (fall-through). A `break` flips the
+ *      sticky `brk` flag (via rewriteSwitchBreaks) and gates the rest.
+ *
+ * The discriminant is bound to a temp only when re-reading it isn't free/safe; a
+ * bare identifier is compared directly \u2014 a synthetic temp would shed its STRING
+ * val-type and mis-fold string `case`s to `false` under strict-=== folding. */
 let swIdx = 0
 function transformSwitch(discriminant, cases) {
   const disc = transform(discriminant)
-  const tmp = `\uE000sw${swIdx++}`
-
-  // Collect case/default
-  const stmts = [['let', ['=', tmp, disc]]]
+  const simple = typeof disc === 'string' || (Array.isArray(disc) && disc[0] == null)
+  const tmp = simple ? disc : `\uE000sw${swIdx++}`
+  const start = `\uE000swst${swIdx++}`
+  const needsBreakFlag = cases.some(c => hasOwnSwitchBreak(c[0] === 'case' ? c[2] : c[1]))
+  const brk = needsBreakFlag ? `\uE000swbrk${swIdx++}` : null
+
+  const n = cases.length
+  let defaultIdx = -1
+  const bodies = cases.map((c, i) => {
+    if (c[0] === 'default') { defaultIdx = i; return transform(c[1]) }
+    return transform(c[2])
+  })
+
+  const stmts = []
+  if (!simple) stmts.push(['let', ['=', tmp, disc]])
+
+  // Phase 1 \u2014 entry index. Init to default's position (or n = "no clause runs"),
+  // then let the first matching label override it via an if/else-if chain.
+  stmts.push(['let', ['=', start, [null, defaultIdx >= 0 ? defaultIdx : n]]])
   let chain = null
-
-  for (let i = cases.length - 1; i >= 0; i--) {
-    const c = cases[i]
-    if (c[0] === 'default') {
-      chain = transform(c[1])
-    } 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]
-    }
+  for (let i = n - 1; i >= 0; i--) {
+    if (cases[i][0] !== 'case') continue
+    const hit = ['=', start, [null, i]]
+    const cond = ['===', tmp, transform(cases[i][1])]
+    chain = chain != null ? ['if', cond, hit, chain] : ['if', cond, hit]
   }
   if (chain) stmts.push(chain)
+  if (brk) stmts.push(['let', ['=', brk, [null, false]]])
+
+  // Phase 2 \u2014 run clauses from the entry index, falling through until a break.
+  for (let i = 0; i < n; i++) {
+    if (bodies[i] == null) continue
+    const body = brk ? rewriteSwitchBreaks(bodies[i], brk) : bodies[i]
+    const reached = ['<=', start, [null, i]]
+    stmts.push(['if', brk ? ['&&', ['!', brk], reached] : reached, body])
+  }
   return [';', ...stmts]
 }