subscript 9.2.0 → 10.0.0

package/util/bundle.js

@@ -0,0 +1,507 @@
+/**
+ * ESM Bundler using subscript's own parser (dogfooding)
+ *
+ * Thin layer: scope analysis + tree transform
+ * Parser comes from the dialect (jessie by default)
+ */
+import { parse } from '../jessie.js';
+import { codegen } from './stringify.js';
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+
+// === AST Utilities ===
+
+/** Walk AST, call fn(node, parent, key) for each node */
+const walk = (node, fn, parent = null, key = null) => {
+  if (!node || typeof node !== 'object') return;
+  fn(node, parent, key);
+  if (Array.isArray(node)) {
+    for (let i = 0; i < node.length; i++) walk(node[i], fn, node, i);
+  }
+};
+
+/** Deep clone AST */
+const clone = node =>
+  !node ? node :
+  Array.isArray(node) ? node.map(clone) :
+  node instanceof RegExp ? new RegExp(node.source, node.flags) :
+  typeof node === 'object' ? Object.fromEntries(Object.entries(node).map(([k,v]) => [k, clone(v)])) :
+  node;
+
+/** Rename identifier in AST - skip property access positions */
+const renameId = (ast, old, neu) => {
+  walk(ast, (node, parent, key) => {
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) {
+        if (node[i] === old) {
+          // Don't rename if this is a property name in a '.' or '?.' access
+          if ((node[0] === '.' || node[0] === '?.') && i === 2) continue;
+          // Don't rename if this is a property name in object literal {a: b} or shorthand {a}
+          if (node[0] === ':' && i === 1 && typeof node[1] === 'string') continue;
+          node[i] = neu;
+        }
+      }
+    }
+  });
+  return ast;
+};
+
+/** Flatten comma nodes into array: [',', 'a', 'b'] → ['a', 'b'], 'x' → ['x'] */
+const flattenComma = node =>
+  Array.isArray(node) && node[0] === ',' ? node.slice(1) :
+  node ? [node] : [];
+
+// === Module Analysis ===
+
+/** Extract string from path node [null, 'path'] (string literal) */
+const getPath = node => Array.isArray(node) && (node[0] === undefined || node[0] === null) ? node[1] : node;
+
+/** Extract imports from AST
+ * New AST shapes:
+ *   import './x.js'           → ['import', [null, path]]
+ *   import X from './x.js'    → ['import', ['from', 'X', [null, path]]]
+ *   import {a,b} from './x'   → ['import', ['from', ['{}', ...], [null, path]]]
+ *   import * as X from './x'  → ['import', ['from', ['as', '*', 'X'], [null, path]]]
+ */
+const getImports = ast => {
+  const imports = [];
+  walk(ast, node => {
+    if (!Array.isArray(node) || node[0] !== 'import') return;
+    const body = node[1];
+    const imp = { node };
+
+    // import './x.js' - bare import: [, 'path'] sparse array with undefined at index 0
+    if (Array.isArray(body) && (body[0] === undefined || body[0] === null)) {
+      imp.path = body[1];
+      imports.push(imp);
+      return;
+    }
+
+    // import X from './x.js' or import {...} from './x.js'
+    if (Array.isArray(body) && body[0] === 'from') {
+      const spec = body[1];
+      const pathNode = body[2];
+      imp.path = getPath(pathNode);
+
+      if (typeof spec === 'string') {
+        // import X from - default import
+        imp.default_ = spec;
+      } else if (Array.isArray(spec)) {
+        if (spec[0] === '{}') {
+          // import { a, b, c as d }
+          const items = spec.slice(1).flatMap(flattenComma);
+          imp.named = items.map(s =>
+            Array.isArray(s) && s[0] === 'as' ? { name: s[1], alias: s[2] } : { name: s, alias: s }
+          );
+        } else if (spec[0] === 'as' && spec[1] === '*') {
+          // import * as X
+          imp.namespace = spec[2];
+        } else if (spec[0] === '*') {
+          // import * as X (alternate shape)
+          imp.namespace = spec[1];
+        }
+      }
+      imports.push(imp);
+    }
+  });
+  return imports;
+};
+
+/** Extract exports from AST
+ * New AST shapes:
+ *   export const x = 1        → ['export', ['const', ['=', 'x', val]]]
+ *   export default x          → ['export', ['default', 'x']]
+ *   export { a }              → ['export', ['{}', 'a']]
+ *   export { a } from './x'   → ['export', ['from', ['{}', 'a'], [null, path]]]
+ *   export * from './x'       → ['export', ['from', '*', [null, path]]]
+ */
+const getExports = ast => {
+  const exports = { named: {}, reexports: [], default_: null };
+
+  walk(ast, node => {
+    if (!Array.isArray(node) || node[0] !== 'export') return;
+    const spec = node[1];
+
+    // export { a } from './x' or export * from './x'
+    if (Array.isArray(spec) && spec[0] === 'from') {
+      const what = spec[1];
+      const pathNode = spec[2];
+      const path = getPath(pathNode);
+
+      if (what === '*') {
+        exports.reexports.push({ star: true, path });
+      } else if (Array.isArray(what) && what[0] === '{}') {
+        const items = what.slice(1).flatMap(flattenComma);
+        const names = items.map(s =>
+          Array.isArray(s) && s[0] === 'as' ? { name: s[1], alias: s[2] } : { name: s, alias: s }
+        );
+        exports.reexports.push({ names, path });
+      }
+      return;
+    }
+
+    // export { a, b }
+    if (Array.isArray(spec) && spec[0] === '{}') {
+      const items = spec.slice(1).flatMap(flattenComma);
+      const names = items.map(s =>
+        Array.isArray(s) && s[0] === 'as' ? { name: s[1], alias: s[2] } : { name: s, alias: s }
+      );
+      for (const { name, alias } of names) exports.named[alias] = name;
+      return;
+    }
+
+    // export default x
+    if (Array.isArray(spec) && spec[0] === 'default') {
+      exports.default_ = spec[1];
+      return;
+    }
+
+    // export const/let/var x = ... - varargs: ['let', decl1, decl2, ...]
+    if (Array.isArray(spec) && (spec[0] === 'const' || spec[0] === 'let' || spec[0] === 'var')) {
+      for (let i = 1; i < spec.length; i++) {
+        const decl = spec[i];
+        if (typeof decl === 'string') {
+          exports.named[decl] = decl;
+        } else if (Array.isArray(decl) && decl[0] === '=') {
+          const name = decl[1];
+          if (typeof name === 'string') exports.named[name] = name;
+        }
+      }
+      return;
+    }
+
+    // export function x() {} or export class x {}
+    if (Array.isArray(spec) && (spec[0] === 'function' || spec[0] === 'class')) {
+      if (typeof spec[1] === 'string') exports.named[spec[1]] = spec[1];
+    }
+  });
+
+  return exports;
+};
+
+/** Get all declared names in AST
+ * New AST shapes:
+ *   const x = 1   → ['const', ['=', 'x', val]]
+ *   let x         → ['let', 'x']
+ *   function f()  → ['function', 'f', ...]
+ *   const a = 1, b = 2 → ['const', ['=', 'a', ...], ['=', 'b', ...]] (varargs)
+ */
+const getDecls = ast => {
+  const decls = new Set();
+
+  const addDecl = node => {
+    if (typeof node === 'string') decls.add(node);
+    else if (Array.isArray(node)) {
+      if (node[0] === '=') {
+        if (typeof node[1] === 'string') decls.add(node[1]);
+      } else if (node[0] === ',') {
+        // Multiple declarations: const a = 1, b = 2 (older AST shape)
+        for (let i = 1; i < node.length; i++) addDecl(node[i]);
+      }
+    }
+  };
+
+  walk(ast, node => {
+    if (!Array.isArray(node)) return;
+    const op = node[0];
+
+    if (op === 'const' || op === 'let' || op === 'var') {
+      // Handle varargs: ['const', decl1, decl2, ...] for multiple declarations
+      for (let i = 1; i < node.length; i++) addDecl(node[i]);
+    }
+    if (op === 'function' || op === 'class') {
+      if (typeof node[1] === 'string') decls.add(node[1]);
+    }
+    if (op === 'export') {
+      const spec = node[1];
+      if (Array.isArray(spec) && (spec[0] === 'const' || spec[0] === 'let' || spec[0] === 'var')) {
+        addDecl(spec[1]);
+      }
+      if (Array.isArray(spec) && (spec[0] === 'function' || spec[0] === 'class') && typeof spec[1] === 'string') {
+        decls.add(spec[1]);
+      }
+    }
+  });
+
+  return decls;
+};
+
+// === AST Transforms ===
+
+/** Remove import/export nodes, extract declarations */
+/** Remove import/export nodes, extract declarations
+ * New AST shapes for export:
+ *   export const x = 1      → ['export', ['const', ...]] → keep ['const', ...]
+ *   export default x        → ['export', ['default', x]] → keep, or convert to __default
+ *   export { a }            → ['export', ['{}', ...]] → remove
+ *   export { a } from './x' → ['export', ['from', ['{}', ...], path]] → remove
+ *   export * from './x'     → ['export', ['from', '*', path]] → remove
+ */
+const stripModuleSyntax = ast => {
+  const defaultExpr = { value: null };
+
+  const process = node => {
+    if (!Array.isArray(node)) return node;
+    const op = node[0];
+
+    if (op === 'import') return null;
+
+    if (op === 'export') {
+      const spec = node[1];
+      // Re-exports: export { a } from './x' or export * from './x'
+      if (Array.isArray(spec) && spec[0] === 'from') return null;
+      // Named exports: export { a, b }
+      if (Array.isArray(spec) && spec[0] === '{}') return null;
+      // Default export
+      if (Array.isArray(spec) && spec[0] === 'default') {
+        defaultExpr.value = spec[1];
+        if (typeof spec[1] === 'string') return null;
+        return ['const', ['=', '__default', spec[1]]];
+      }
+      // Declaration export: export const x = 1
+      return spec;
+    }
+
+    if (op === ';') {
+      const parts = node.slice(1).map(process).filter(Boolean);
+      if (parts.length === 0) return null;
+      if (parts.length === 1) return parts[0];
+      return [';', ...parts];
+    }
+
+    return node;
+  };
+
+  return { ast: process(ast), defaultExpr: defaultExpr.value };
+};
+
+// === Path Resolution ===
+
+const resolvePath = (from, to) => {
+  if (!to.startsWith('.')) return to;
+  const base = from.split('/').slice(0, -1);
+  for (const part of to.split('/')) {
+    if (part === '..') base.pop();
+    else if (part !== '.') base.push(part);
+  }
+  let path = base.join('/');
+  if (!path.endsWith('.js')) path += '.js';
+  return path;
+};
+
+// === Bundler ===
+
+/**
+ * Bundle ES modules into single file
+ * @param {string} entry - Entry file path
+ * @param {(path: string) => string|Promise<string>} read - File reader
+ */
+export async function bundle(entry, read) {
+  const modules = new Map();
+  const order = [];
+
+  async function load(path) {
+    if (modules.has(path)) return;
+    modules.set(path, null);
+
+    const code = await read(path);
+    const ast = parse(code);
+    const imports = getImports(ast);
+    const exports = getExports(ast);
+    const decls = getDecls(ast);
+
+    for (const imp of imports) {
+      imp.resolved = resolvePath(path, imp.path);
+      await load(imp.resolved);
+    }
+    for (const re of exports.reexports) {
+      re.resolved = resolvePath(path, re.path);
+      await load(re.resolved);
+    }
+
+    modules.set(path, { ast: clone(ast), imports, exports, decls });
+    order.push(path);
+  }
+
+  await load(entry);
+
+  // Detect conflicts
+  const allDecls = new Map();
+  for (const [path, mod] of modules) {
+    const importAliases = new Set();
+    for (const imp of mod.imports) {
+      if (imp.default_) importAliases.add(imp.default_);
+      if (imp.namespace) importAliases.add(imp.namespace);
+      if (imp.named) for (const { alias } of imp.named) importAliases.add(alias);
+    }
+
+    for (const name of mod.decls) {
+      if (importAliases.has(name)) continue;
+      if (!allDecls.has(name)) allDecls.set(name, []);
+      allDecls.get(name).push(path);
+    }
+  }
+
+  // Build rename maps
+  const renames = new Map();
+  for (const [name, paths] of allDecls) {
+    if (paths.length > 1) {
+      for (const path of paths) {
+        if (!renames.has(path)) renames.set(path, {});
+        // Make valid JS identifier: replace non-alphanumeric with underscore
+        const prefix = path.split('/').pop().replace('.js', '').replace(/[^a-zA-Z0-9]/g, '_') + '_';
+        renames.get(path)[name] = prefix + name;
+      }
+    }
+  }
+
+  const traceDefault = path => {
+    const mod = modules.get(path);
+    if (!mod) return null;
+    const def = mod.exports.default_;
+    if (!def) return null;
+    if (typeof def === 'string') {
+      const pathRenames = renames.get(path) || {};
+      if (pathRenames[def]) return pathRenames[def];
+      const defImp = mod.imports.find(i => i.default_ === def);
+      if (defImp) return traceDefault(defImp.resolved);
+      return def;
+    }
+    return '__default';
+  };
+
+  // Transform each module
+  const chunks = [];
+  for (const path of order) {
+    const mod = modules.get(path);
+    const pathRenames = renames.get(path) || {};
+
+    let ast = clone(mod.ast);
+    for (const [old, neu] of Object.entries(pathRenames)) {
+      renameId(ast, old, neu);
+    }
+
+    for (const imp of mod.imports) {
+      const dep = modules.get(imp.resolved);
+      if (!dep) continue;
+      const depRenames = renames.get(imp.resolved) || {};
+
+      if (imp.named) {
+        for (const { name, alias } of imp.named) {
+          // `name` is the exported name, look up what local name it maps to in the dep
+          const localName = dep.exports.named[name] || name;
+          // Check if that local name was renamed in the dep
+          const resolved = depRenames[localName] || localName;
+          if (alias !== resolved) renameId(ast, alias, resolved);
+        }
+      }
+
+      if (imp.default_) {
+        const resolved = traceDefault(imp.resolved);
+        if (resolved && imp.default_ !== resolved) {
+          renameId(ast, imp.default_, resolved);
+        }
+      }
+
+      if (imp.namespace) {
+        walk(ast, node => {
+          if (Array.isArray(node) && node[0] === '.' && node[1] === imp.namespace) {
+            const prop = node[2];
+            if (typeof prop === 'string' && dep.exports.named[prop]) {
+              const resolved = depRenames[dep.exports.named[prop]] || dep.exports.named[prop];
+              node.length = 0;
+              node.push(resolved);
+            }
+          }
+        });
+      }
+    }
+
+    const { ast: stripped } = stripModuleSyntax(ast);
+
+    if (stripped) {
+      const code = codegen(stripped);
+      if (code.trim()) {
+        chunks.push(`// === ${path} ===\n${code}`);
+      }
+    }
+  }
+
+  // Generate exports
+  const entryMod = modules.get(entry);
+  const entryRenames = renames.get(entry) || {};
+  const exportLines = [];
+
+  // Resolve all named exports including from re-exports
+  const resolveExports = (path, seen = new Set()) => {
+    if (seen.has(path)) return {};
+    seen.add(path);
+    const mod = modules.get(path);
+    if (!mod) return {};
+    const pathRenames = renames.get(path) || {};
+    const result = {};
+
+    // Direct named exports
+    for (const [exp, local] of Object.entries(mod.exports.named)) {
+      result[exp] = pathRenames[local] || local;
+    }
+
+    // Re-exports
+    for (const re of mod.exports.reexports) {
+      const depRenames = renames.get(re.resolved) || {};
+      if (re.star) {
+        // export * from './x' - get all exports from that module
+        const depExports = resolveExports(re.resolved, seen);
+        for (const [exp, resolved] of Object.entries(depExports)) {
+          if (!(exp in result)) result[exp] = resolved; // don't override local exports
+        }
+      } else if (re.names) {
+        // export { a, b } from './x'
+        const depMod = modules.get(re.resolved);
+        if (depMod) {
+          for (const { name, alias } of re.names) {
+            const local = depMod.exports.named[name] || name;
+            result[alias] = depRenames[local] || local;
+          }
+        }
+      }
+    }
+    return result;
+  };
+
+  const allExports = resolveExports(entry);
+  for (const [exp, resolved] of Object.entries(allExports)) {
+    exportLines.push(exp === resolved ? exp : `${resolved} as ${exp}`);
+  }
+
+  if (entryMod.exports.default_) {
+    const resolved = traceDefault(entry) || '__default';
+    exportLines.push(`${resolved} as default`);
+  }
+
+  let result = chunks.join('\n\n');
+  if (exportLines.length) {
+    result += `\n\nexport { ${exportLines.join(', ')} }`;
+  }
+
+  return result;
+}
+
+/** Bundle with Node.js fs */
+export const bundleFile = (entry) => bundle(resolve(entry), path => readFile(path, 'utf-8'));
+
+// CLI
+if (typeof process !== 'undefined' && process.argv[1]?.includes('bundle')) {
+  const entry = process.argv[2];
+  if (!entry) {
+    console.error('Usage: node bundle.js <entry>');
+    process.exit(1);
+  }
+  bundleFile(entry)
+    .then(result => console.log(result))
+    .catch(e => {
+      console.error('Error:', e.message);
+      console.error(e.stack);
+      process.exit(1);
+    });
+}

package/util/stringify.js

@@ -0,0 +1,172 @@
+/**
+ * AST → JS Source String (codegen)
+ *
+ * Simple recursive stringifier using pattern matching on AST structure.
+ */
+
+// Operator-specific overrides
+export const generators = {};
+
+// Register custom generator
+export const generator = (op, fn) => generators[op] = fn;
+
+// Stringify AST to JS source
+export const codegen = node => {
+  // Handle undefined/null
+  if (node === undefined) return 'undefined';
+  if (node === null) return 'null';
+  if (node === '') return '';
+
+  // Identifier
+  if (!Array.isArray(node)) return String(node);
+
+  const [op, ...args] = node;
+
+  // Literal: [, value]
+  if (op === undefined) return typeof args[0] === 'string' ? JSON.stringify(args[0]) : String(args[0]);
+
+  // Custom generator
+  if (generators[op]) return generators[op](...args);
+
+  // Brackets: [], {}, ()
+  if (op === '[]' || op === '{}' || op === '()') {
+    const prefix = args.length > 1 ? codegen(args.shift()) : '';
+    // Empty brackets
+    if (args[0] === undefined || args[0] === null) return prefix + op;
+    // Comma sequence: [',', a, b, c] → a, b, c  (null → empty for sparse arrays)
+    const inner = args[0]?.[0] === ','
+      ? args[0].slice(1).map(a => a === null ? '' : codegen(a)).join(', ')
+      : codegen(args[0]);
+    return prefix + op[0] + inner + op[1];
+  }
+
+  // Unary: [op, a]
+  if (args.length === 1) return op + codegen(args[0]);
+
+  // N-ary/sequence: comma, semicolon
+  if (op === ',' || op === ';') return args.filter(Boolean).map(codegen).join(op === ';' ? '; ' : ', ');
+
+  // Binary: [op, a, b]
+  if (args.length === 2) {
+    const [a, b] = args;
+    // Postfix: [op, a, null]
+    if (b === null) return codegen(a) + op;
+    // Property access: no spaces
+    if (op === '.') return codegen(a) + '.' + b;
+    return codegen(a) + ' ' + op + ' ' + codegen(b);
+  }
+
+  // Ternary: a ? b : c
+  if (op === '?' && args.length === 3) {
+    return codegen(args[0]) + ' ? ' + codegen(args[1]) + ' : ' + codegen(args[2]);
+  }
+
+  // Fallback n-ary
+  return args.filter(Boolean).map(codegen).join(op === ';' ? '; ' : ', ');
+};
+
+// --- Statement generators (need structure) ---
+
+generator('block', body => body === undefined ? '{}' : '{ ' + codegen(body) + ' }');
+
+// Variables: ['let', decl] or ['let', decl1, decl2, ...]
+const varGen = kw => (...args) => kw + ' ' + args.map(codegen).join(', ');
+generator('let', varGen('let'));
+generator('const', varGen('const'));
+generator('var', varGen('var'));
+
+// Control flow
+const wrap = s => s?.[0] === 'block' ? codegen(s) : '{ ' + (s ? codegen(s) : '') + ' }';
+generator('if', (cond, then, els) => 'if (' + codegen(cond) + ') ' + wrap(then) + (els ? ' else ' + wrap(els) : ''));
+generator('while', (cond, body) => 'while (' + codegen(cond) + ') ' + wrap(body));
+generator('do', (body, cond) => 'do ' + wrap(body) + ' while (' + codegen(cond) + ')');
+generator('for', (head, body) => {
+  if (head?.[0] === ';') {
+    const [, init, cond, step] = head;
+    return 'for (' + (init ? codegen(init) : '') + '; ' + (cond ? codegen(cond) : '') + '; ' + (step ? codegen(step) : '') + ') ' + wrap(body);
+  }
+  return 'for (' + codegen(head) + ') ' + wrap(body);
+});
+
+generator('return', a => a === undefined ? 'return' : 'return ' + codegen(a));
+generator('break', () => 'break');
+generator('continue', () => 'continue');
+generator('throw', a => 'throw ' + codegen(a));
+
+// Try/Catch - nested structure
+generator('try', body => 'try { ' + codegen(body) + ' }');
+generator('catch', (tryExpr, param, body) => codegen(tryExpr) + ' catch (' + codegen(param) + ') { ' + codegen(body) + ' }');
+generator('finally', (expr, body) => codegen(expr) + ' finally { ' + codegen(body) + ' }');
+
+// Functions
+generator('function', (name, params, body) => {
+  const args = !params ? '' : params[0] === ',' ? params.slice(1).map(codegen).join(', ') : codegen(params);
+  const b = body?.[0] === 'block' ? codegen(body) : '{ ' + (body ? codegen(body) : '') + ' }';
+  return 'function' + (name ? ' ' + name : '') + '(' + args + ') ' + b;
+});
+
+generator('=>', (params, body) => {
+  if (params?.[0] === '()') params = params[1];
+  const args = !params ? '()' : typeof params === 'string' ? params :
+    params[0] === ',' ? '(' + params.slice(1).map(codegen).join(', ') + ')' : '(' + codegen(params) + ')';
+  return args + ' => ' + codegen(body);
+});
+
+// Class
+generator('class', (name, base, body) =>
+  'class' + (name ? ' ' + name : '') + (base ? ' extends ' + codegen(base) : '') + ' { ' + (body ? codegen(body) : '') + ' }');
+
+// Async/Await/Yield
+generator('async', fn => 'async ' + codegen(fn));
+generator('await', a => 'await ' + codegen(a));
+generator('yield', a => a !== undefined ? 'yield ' + codegen(a) : 'yield');
+generator('yield*', a => 'yield* ' + codegen(a));
+
+// Switch
+generator('switch', (expr, body) => 'switch (' + codegen(expr) + ') ' + codegen(body));
+generator('case', (test, body) => 'case ' + codegen(test) + ':' + (body ? ' ' + codegen(body) : ''));
+generator('default:', body => 'default:' + (body ? ' ' + codegen(body) : ''));
+
+// Keywords
+generator('typeof', a => '(typeof ' + codegen(a) + ')');
+generator('void', a => '(void ' + codegen(a) + ')');
+generator('delete', a => '(delete ' + codegen(a) + ')');
+generator('new', a => 'new ' + codegen(a));
+generator('instanceof', (a, b) => '(' + codegen(a) + ' instanceof ' + codegen(b) + ')');
+
+// Optional chaining
+generator('?.', (a, b) => codegen(a) + '?.' + b);
+generator('?.[]', (a, b) => codegen(a) + '?.[' + codegen(b) + ']');
+generator('?.()', (a, b) => codegen(a) + '?.(' + (!b ? '' : b[0] === ',' ? b.slice(1).map(codegen).join(', ') : codegen(b)) + ')');
+
+// Object literal
+generator(':', (k, v) => (typeof k === 'string' ? k : '[' + codegen(k) + ']') + ': ' + codegen(v));
+
+// Template literals
+generator('`', (...parts) => '`' + parts.map(p => p?.[0] === undefined ? String(p[1]).replace(/`/g, '\\`').replace(/\$/g, '\\$') : '${' + codegen(p) + '}').join('') + '`');
+generator('``', (tag, ...parts) => codegen(tag) + '`' + parts.map(p => p?.[0] === undefined ? String(p[1]).replace(/`/g, '\\`').replace(/\$/g, '\\$') : '${' + codegen(p) + '}').join('') + '`');
+
+// Getter/Setter
+generator('get', (name, body) => 'get ' + name + '() { ' + (body ? codegen(body) : '') + ' }');
+generator('set', (name, param, body) => 'set ' + name + '(' + param + ') { ' + (body ? codegen(body) : '') + ' }');
+generator('static', a => 'static ' + codegen(a));
+
+// Non-JS operators (emit as helpers)
+generator('..', (a, b) => 'range(' + codegen(a) + ', ' + codegen(b) + ')');
+generator('..<', (a, b) => 'range(' + codegen(a) + ', ' + codegen(b) + ', true)');
+generator('as', (a, b) => b ? codegen(a) + ' as ' + b : codegen(a));  // import alias or type assertion
+generator('is', (a, b) => '(' + codegen(a) + ' instanceof ' + codegen(b) + ')');
+generator('defer', a => '/* defer */ ' + codegen(a));
+
+// For-in/of helper
+generator('in', (a, b) => codegen(a) + ' in ' + codegen(b));
+generator('of', (a, b) => codegen(a) + ' of ' + codegen(b));
+generator('for await', (head, body) => 'for await (' + codegen(head) + ') ' + wrap(body));
+
+// Module syntax
+generator('export', spec => 'export ' + codegen(spec));
+generator('import', spec => 'import ' + codegen(spec));
+generator('from', (what, path) => codegen(what) + ' from ' + codegen(path));
+generator('default', a => 'default ' + codegen(a));
+
+export default codegen;