jz 0.5.1 → 0.7.0

package/jzify/classes.js

@@ -0,0 +1,328 @@
+/**
+ * Class and object-method `this` lowering.
+ * @module jzify/classes
+ */
+
+import { extractParams as paramList, objectLiteralEntries } from '../src/ast.js'
+import { err } from '../src/ctx.js'
+
+export function createClassLowering({ transform, names, JC }) {
+// === class lowering ===
+//
+// A class is lowered to a factory arrow. Instance state is a plain object;
+// methods are per-instance arrows capturing it (so `obj.m()` keeps working
+// without a separate `this` argument); `this` is renamed to that object;
+// `new C(a)` is already turned into `C(a)` by the `new` handler.
+//
+//   class Point { x = 0; y; constructor(a,b){ this.x = a; this.y = b }
+//                 dist(){ return Math.hypot(this.x, this.y) } }
+//   →
+//   let Point = (a, b) => {
+//     let selfN = { x: undefined, y: undefined,
+//                         dist: () => Math.hypot(selfN.x, selfN.y) }
+//     selfN.x = 0          // field initializers, in declaration order
+//     selfN.x = a          // then the constructor body
+//     selfN.y = b
+//     return selfN
+//   }
+//
+// 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).
+const DEFAULT_DERIVED_CTOR_ARITY = 8
+
+const arrowParams = params => Array.isArray(params) && params[0] === '()' ? params : ['()', params]
+const block = b => Array.isArray(b) && b[0] === '{}' ? b : ['{}', b]
+
+const classBodyItems = (body) =>
+  body == null ? [] : Array.isArray(body) && body[0] === ';' ? body.slice(1) : [body]
+
+// Rename `this` → `to`, not crossing into a nested `function`/`class` (those
+// rebind `this`); arrows inherit `this`, so they are crossed. Property *names*
+// (`obj.this`, `{this: …}` value-side only) are left alone.
+function renameThis(node, to) {
+  if (node === 'this') return to
+  if (!Array.isArray(node)) return node
+  if (node[0] === 'function' || node[0] === 'class') return node
+  if (node[0] === '.' || node[0] === '?.') return [node[0], renameThis(node[1], to), node[2]]
+  if (node[0] === ':') return [node[0], node[1], renameThis(node[2], 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 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 = objectLiteralEntries(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 = names.objThis()
+  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]
+}
+
+// Route through the shared compiler error channel (uniform Error shape + stack
+// cleanup for dependents). jzify runs pre-emit, so err()'s location/function
+// enrichment guards simply no-op; the `jzify:` prefix marks the phase.
+function jzifyError(msg) { err(`jzify: ${msg}`) }
+
+function lowerClass(name, heritage, body) {
+  let ctorParams = null, ctorBody = null
+  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] === '=>') {
+      const key = constStringKey(it[1])
+      if (key == null) jzifyError(JC.computedMember)
+      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') {
+        const key = constStringKey(lhs[1])
+        if (key == null) jzifyError(JC.computedStaticField)
+        statics.push([key, it[2]])
+        continue
+      }
+      const key = constStringKey(lhs)
+      if (key == null) jzifyError(JC.computedField)
+      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(JC.computedStaticMember)
+      statics.push([key, it[1][2], true])
+      continue
+    }
+    if (it[0] === 'get' || it[0] === 'set') jzifyError(JC.accessor)
+    if (it[0] === 'static') jzifyError(JC.staticMember)
+    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, names.classSuper(i)]))
+    const unsupportedSuperProp = node => node != null && hasSuperProp(rewriteSuperMethodCalls(node, dummySuperVars))
+    if (
+      unsupportedSuperProp(ctorBody) ||
+      fields.some(([, init]) => unsupportedSuperProp(init)) ||
+      methods.some(([, , mbody]) => unsupportedSuperProp(mbody))
+    )
+      jzifyError(JC.superProp)
+  }
+  const self = names.classSelf()
+  const UNDEF = []                                  // jessie's node for `undefined`
+  // 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.
+  const litProps = [], deferred = []
+  for (const [fname, init] of fields) {
+    if (init != null && !usesThis(init)) litProps.push([':', fname, transform(init)])
+    else { litProps.push([':', fname, UNDEF]); if (init != null) deferred.push([fname, init]) }
+  }
+  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]]
+  let params = ctorParams ?? ['()', null]
+  const dynamicBase = heritage != null && typeof heritage !== 'string'
+  const baseRef = heritage == null ? null : dynamicBase ? names.classBase() : 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) => names.classSuperArg(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 = names.classSuper(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.
+  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]
+    if (Array.isArray(cb) && cb[0] === ';') stmts.push(...cb.slice(1).filter(s => s != null))
+    else if (cb != null) stmts.push(cb)
+  }
+  stmts.push(['return', self])
+  const factory = ['=>', arrowParams(params), ['{}', [';', ...stmts]]]
+  if (!dynamicBase && statics.length === 0) return factory
+
+  const cls = name || names.classStatic()
+  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
+}
+
+  return { lowerClass, lowerObjectLiteralThis, lowerArrayConstructor }
+}

package/jzify/hoist-vars.js

@@ -0,0 +1,177 @@
+/**
+ * Var hoisting — bubble `var` to scope top, normalize for-heads, destructure patterns.
+ * @module jzify/hoist-vars
+ */
+
+import { JZ_BLOCK_OPS } from '../src/ast.js'
+
+export const isDestructurePat = p =>
+  Array.isArray(p) && (p[0] === '[]' || p[0] === '{}' || (p[0] === '=' && isDestructurePat(p[1])))
+
+export function hoistVars(node, names) {
+  if (node == null || !Array.isArray(node)) return node
+  const op = node[0]
+  if (op === 'function') {
+    const inner = new Set()
+    let body = hoistVars(node[3], inner)
+    if (inner.size) body = prependDecls(body, inner)
+    return ['function', node[1], node[2], body]
+  }
+  if (op === '=>') {
+    const inner = new Set()
+    let body = hoistVars(node[2], inner)
+    if (inner.size) body = prependDecls(body, inner)
+    return ['=>', node[1], body]
+  }
+  if (op === 'in' || op === 'of') {
+    let lhs = node[1]
+    if (Array.isArray(lhs) && lhs[0] === 'var' && typeof lhs[1] === 'string' && lhs.length === 2) {
+      names.add(lhs[1])
+      lhs = lhs[1]
+    } else {
+      lhs = hoistVars(lhs, names)
+    }
+    return [op, lhs, hoistVars(node[2], names)]
+  }
+  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)]
+  }
+  if (op === 'for') {
+    const head = node[1]
+    let h2
+    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)]
+    } else if (Array.isArray(head) && head[0] === ';') {
+      h2 = [';']
+      for (let i = 1; i < head.length; i++) h2.push(hoistVars(head[i], names))
+    } else {
+      h2 = hoistVars(head, names)
+    }
+    return ['for', h2, hoistVars(node[2], names)]
+  }
+  if (op === 'var') {
+    const decls = []
+    for (let i = 1; i < node.length; i++) {
+      const d = node[i]
+      if (typeof d === 'string') { names.add(d); continue }
+      if (Array.isArray(d) && d[0] === '=' && typeof d[1] === 'string') {
+        names.add(d[1])
+        decls.push(['=', d[1], hoistVars(d[2], names)])
+      }
+    }
+    if (decls.length === 0) return null
+    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
+  }
+  if (op === ';') {
+    const out = [op]
+    for (let i = 1; i < node.length; i++) {
+      const child = node[i]
+      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
+  }
+  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
+}
+
+export 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)
+}
+
+export function prependDecls(body, names) {
+  const decl = ['let', ...names]
+  if (Array.isArray(body) && body[0] === ';') return [';', decl, ...body.slice(1)]
+  if (Array.isArray(body) && body[0] === '{}') {
+    const inner = body[1]
+    if (Array.isArray(inner) && inner[0] === ';') return ['{}', [';', decl, ...inner.slice(1)]]
+    if (inner == null) return ['{}', decl]
+    return ['{}', [';', decl, inner]]
+  }
+  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
+  }
+  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
+}
+
+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]
+}

package/jzify/index.js

@@ -0,0 +1,51 @@
+/**
+ * jzify — Transform JS AST into jz-compatible form.
+ *
+ * Crockford-aligned: eliminates bad parts, enforces good practices.
+ * Runs before prepare() as an AST→AST pass.
+ *
+ * @module jzify
+ */
+
+import { JZIFY_CLASS_ERRORS as JC } from '../src/op-policy.js'
+import { createNames } from './names.js'
+import { foldStaticExportHelpers, foldStaticBundlerHelpers, canonicalizeObjectIdioms } from './bundler.js'
+import { createSwitchLowering, normalizeCaseBody } from './switch.js'
+import { createClassLowering } from './classes.js'
+import { hoistVars, prependDecls } from './hoist-vars.js'
+import { createArgumentsLowering } from './arguments.js'
+import { createTransform } from './transform.js'
+
+const names = createNames()
+const { lowerArguments, transformPattern, bindTransform } = createArgumentsLowering(names)
+
+let lowerClass, lowerObjectLiteralThis, lowerArrayConstructor, transformSwitch
+let transform, transformScope
+
+;({ transform, transformScope } = createTransform({
+  names,
+  lowerArguments,
+  transformPattern,
+  normalizeCaseBody,
+  transformSwitch: (...a) => transformSwitch(...a),
+  lowerClass: () => lowerClass,
+  lowerObjectLiteralThis: () => lowerObjectLiteralThis,
+  lowerArrayConstructor: () => lowerArrayConstructor,
+}))
+bindTransform(transform)
+
+;({ lowerClass, lowerObjectLiteralThis, lowerArrayConstructor } = createClassLowering({ transform, names, JC }))
+transformSwitch = createSwitchLowering(transform, names)
+
+/**
+ * Transform AST in-place. Returns transformed AST.
+ * @param {Array} ast - subscript/jessie parsed AST
+ * @returns {Array} Transformed AST
+ */
+export default function jzify(ast) {
+  names.reset()
+  const hoisted = new Set()
+  ast = hoistVars(ast, hoisted)
+  if (hoisted.size) ast = prependDecls(ast, hoisted)
+  return foldStaticBundlerHelpers(foldStaticExportHelpers(canonicalizeObjectIdioms(transformScope(ast))))
+}

package/jzify/names.js

@@ -0,0 +1,37 @@
+/**
+ * Synthetic temp-name factory for jzify lowering passes.
+ *
+ * Namespaces use private-use Unicode prefixes so they never collide with user code.
+ *
+ * @module jzify/names
+ */
+
+import { T } from '../src/ast.js'
+
+/** @returns fresh name counters, all reset together at jzify entry. */
+export function createNames() {
+  let swIdx = 0
+  let argsIdx = 0
+  let doIdx = 0
+  let classIdx = 0
+  let objThisIdx = 0
+  let staticClassIdx = 0
+  let classBaseIdx = 0
+
+  return {
+    reset() {
+      swIdx = argsIdx = doIdx = classIdx = objThisIdx = staticClassIdx = classBaseIdx = 0
+    },
+    switchDisc: () => `${T}sw${swIdx++}`,
+    switchStart: () => `${T}swst${swIdx++}`,
+    switchBreak: () => `${T}swbrk${swIdx++}`,
+    arg: () => `\uE001arg${argsIdx++}`,
+    doFlag: () => `\uE002do${doIdx++}`,
+    objThis: () => `\uE003obj${objThisIdx++}`,
+    classSelf: () => `\uE003self${classIdx++}`,
+    classBase: () => `\uE003base${classBaseIdx++}`,
+    classStatic: () => `\uE003class${staticClassIdx++}`,
+    classSuperArg: i => `\uE003superArg${classIdx}_${i}`,
+    classSuper: i => `\uE003super${classIdx}_${i}`,
+  }
+}