@tsvm/ir 0.1.0

package/dist/index.js

@@ -0,0 +1,3593 @@
+// src/ir.ts
+var IRModuleBuilder = class {
+  constructor(sourceFile) {
+    this.sourceFile = sourceFile;
+  }
+  sourceFile;
+  functions = [];
+  globals = [];
+  imports = [];
+  exports = [];
+  constantPool = [];
+  constantMap = /* @__PURE__ */ new Map();
+  nextFunctionId = 1;
+  addFunction(fn) {
+    this.functions.push(fn);
+  }
+  addGlobal(g) {
+    this.globals.push(g);
+  }
+  addImport(imp) {
+    this.imports.push(imp);
+  }
+  addExport(exp) {
+    this.exports.push(exp);
+  }
+  addConstant(kind, value) {
+    const key = `${kind}:${value}`;
+    if (this.constantMap.has(key)) {
+      return this.constantMap.get(key);
+    }
+    const index = this.constantPool.length;
+    this.constantPool.push({ index, kind, value });
+    this.constantMap.set(key, index);
+    return index;
+  }
+  build() {
+    let blockCount = 0;
+    let instructionCount = 0;
+    for (const f of this.functions) {
+      blockCount += f.blocks.length;
+      for (const b of f.blocks) {
+        instructionCount += b.instructions.length;
+      }
+    }
+    return {
+      id: `mod_${Date.now()}`,
+      sourceFile: this.sourceFile,
+      functions: this.functions,
+      globals: this.globals,
+      imports: this.imports,
+      exports: this.exports,
+      constantPool: this.constantPool,
+      metadata: {
+        sourceFile: this.sourceFile,
+        originalByteSize: 0,
+        functionCount: this.functions.length,
+        blockCount,
+        instructionCount,
+        buildTimestamp: Date.now()
+      }
+    };
+  }
+  getNextFunctionId() {
+    return `fn_${this.nextFunctionId++}`;
+  }
+};
+var IRFunctionBuilder = class {
+  constructor(id, name, returnType) {
+    this.id = id;
+    this.name = name;
+    this.returnType = returnType;
+  }
+  id;
+  name;
+  returnType;
+  blocks = [];
+  params = [];
+  locals = [];
+  attributes = [];
+  capturedVariables = [];
+  nextRegId = 0;
+  nextBlockId = 0;
+  addParam(name, type, isRest = false, defaultValue) {
+    const reg = this.allocRegister();
+    this.params.push({ name, register: reg, type, isRest, defaultValue });
+    return reg;
+  }
+  addLocal(name, type, isCaptured = false) {
+    const reg = this.allocRegister();
+    this.locals.push({ name, register: reg, type, isCaptured });
+    return reg;
+  }
+  addAttribute(attr) {
+    if (!this.attributes.includes(attr)) {
+      this.attributes.push(attr);
+    }
+  }
+  addCapturedVariable(name) {
+    if (!this.capturedVariables.includes(name)) {
+      this.capturedVariables.push(name);
+    }
+  }
+  allocRegister() {
+    return `r${this.nextRegId++}`;
+  }
+  createBlock(label) {
+    const id = `b${this.nextBlockId++}`;
+    const block = new BasicBlockBuilder(id, label);
+    return block;
+  }
+  addBlock(block) {
+    this.blocks.push(block);
+  }
+  getBlockCount() {
+    return this.blocks.length;
+  }
+  build(isVirtualized = true, isExported = false) {
+    return {
+      id: this.id,
+      name: this.name,
+      params: this.params,
+      returnType: this.returnType,
+      blocks: this.blocks,
+      locals: this.locals,
+      isVirtualized,
+      isExported,
+      attributes: this.attributes,
+      capturedVariables: this.capturedVariables
+    };
+  }
+};
+var BasicBlockBuilder = class {
+  constructor(id, label) {
+    this.id = id;
+    this.label = label;
+  }
+  id;
+  label;
+  instructions = [];
+  terminator;
+  predecessors = [];
+  successors = [];
+  addInstruction(opcode, operands, result) {
+    this.instructions.push({ opcode, operands, result });
+  }
+  setTerminator(term) {
+    this.terminator = term;
+    this.successors = [...term.targets];
+  }
+  addPredecessor(id) {
+    if (!this.predecessors.includes(id)) {
+      this.predecessors.push(id);
+    }
+  }
+  getInstructionCount() {
+    return this.instructions.length;
+  }
+  getPredecessorCount() {
+    return this.predecessors.length;
+  }
+  getTerminatorKind() {
+    return this.terminator?.kind;
+  }
+  build() {
+    if (!this.terminator) {
+      this.terminator = { kind: "unreachable", targets: [] };
+    }
+    return {
+      id: this.id,
+      label: this.label,
+      instructions: this.instructions,
+      terminator: this.terminator,
+      predecessors: this.predecessors,
+      successors: this.successors,
+      phiNodes: []
+    };
+  }
+};
+function createInstruction(opcode, operands, result) {
+  return { opcode, operands, result };
+}
+function createTerminator(kind, targets, condition, returnValue) {
+  return { kind, targets, condition, returnValue };
+}
+
+// src/builder.ts
+import ts3 from "typescript";
+import { DiagnosticSeverity, IRType, OpCode as OpCode2, OperandKind as OperandKind2, ConstantKind as ConstantKind2, FunctionAttribute } from "@tsvm/shared";
+
+// src/lowering/types.ts
+var LEXICAL_THIS_CAPTURE = "$$vm_lexical_this";
+var LEXICAL_NEW_TARGET_CAPTURE = "$$vm_lexical_new_target";
+
+// src/lowering/utils.ts
+import ts from "typescript";
+function pushUnique(target, value) {
+  if (!target.includes(value)) {
+    target.push(value);
+  }
+}
+function isNestedFunctionLike(node) {
+  return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node) || ts.isConstructorDeclaration(node);
+}
+function isTypePosition(node) {
+  const parent = node.parent;
+  return ts.isTypeNode(parent) || ts.isTypeAliasDeclaration(parent) || ts.isHeritageClause(parent);
+}
+function isIdentifierReference(node) {
+  const parent = node.parent;
+  if (!parent || isTypePosition(node)) {
+    return false;
+  }
+  if (ts.isPropertyAccessExpression(parent) && parent.name === node || ts.isPropertyAssignment(parent) && parent.name === node || ts.isShorthandPropertyAssignment(parent) && parent.name !== node || ts.isMethodDeclaration(parent) && parent.name === node || ts.isPropertyDeclaration(parent) && parent.name === node || ts.isPropertySignature(parent) && parent.name === node || ts.isBindingElement(parent) && parent.name === node || ts.isVariableDeclaration(parent) && parent.name === node || ts.isParameter(parent) && parent.name === node || ts.isFunctionDeclaration(parent) && parent.name === node || ts.isFunctionExpression(parent) && parent.name === node || ts.isLabeledStatement(parent) && parent.label === node || ts.isBreakOrContinueStatement(parent) && parent.label === node) {
+    return false;
+  }
+  return true;
+}
+function collectFunctionLocalNames(node) {
+  const names = /* @__PURE__ */ new Set();
+  const isThisParameter = (param) => ts.isIdentifier(param.name) && param.name.text === "this";
+  const collectBindingNames = (bindingName) => {
+    if (ts.isIdentifier(bindingName)) {
+      names.add(bindingName.text);
+      return;
+    }
+    for (const element of bindingName.elements) {
+      if (ts.isOmittedExpression(element)) {
+        continue;
+      }
+      collectBindingNames(element.name);
+    }
+  };
+  node.parameters.forEach((param) => {
+    if (isThisParameter(param)) {
+      return;
+    }
+    collectBindingNames(param.name);
+  });
+  if ((ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) && node.name) {
+    names.add(node.name.text);
+  }
+  const visit = (current) => {
+    if (current !== node && isNestedFunctionLike(current)) {
+      return;
+    }
+    if (ts.isVariableDeclaration(current)) {
+      collectBindingNames(current.name);
+    }
+    if (ts.isCatchClause(current) && current.variableDeclaration) {
+      collectBindingNames(current.variableDeclaration.name);
+    }
+    ts.forEachChild(current, visit);
+  };
+  if (node.body) {
+    ts.forEachChild(node.body, visit);
+  }
+  return names;
+}
+function analyzeFunctionClosures(node, availableOuterNames) {
+  const localNames = collectFunctionLocalNames(node);
+  const capturedFromOuter = [];
+  const capturedByDescendants = /* @__PURE__ */ new Set();
+  const childAvailableOuterNames = new Set(availableOuterNames);
+  for (const name of localNames) {
+    childAvailableOuterNames.add(name);
+  }
+  const visit = (current) => {
+    if (current !== node && isNestedFunctionLike(current)) {
+      const childAnalysis = analyzeFunctionClosures(current, childAvailableOuterNames);
+      for (const name of childAnalysis.capturedFromOuter) {
+        if (localNames.has(name) || name === LEXICAL_THIS_CAPTURE || name === LEXICAL_NEW_TARGET_CAPTURE) {
+          capturedByDescendants.add(name);
+        } else if (availableOuterNames.has(name)) {
+          pushUnique(capturedFromOuter, name);
+        }
+      }
+      return;
+    }
+    if (ts.isIdentifier(current) && isIdentifierReference(current)) {
+      const name = current.text;
+      if (!localNames.has(name) && availableOuterNames.has(name)) {
+        pushUnique(capturedFromOuter, name);
+      }
+    }
+    if (ts.isArrowFunction(node) && current.kind === ts.SyntaxKind.ThisKeyword && availableOuterNames.has(LEXICAL_THIS_CAPTURE)) {
+      pushUnique(capturedFromOuter, LEXICAL_THIS_CAPTURE);
+    }
+    if (ts.isArrowFunction(node) && ts.isMetaProperty(current) && current.keywordToken === ts.SyntaxKind.NewKeyword && current.name.text === "target" && availableOuterNames.has(LEXICAL_NEW_TARGET_CAPTURE)) {
+      pushUnique(capturedFromOuter, LEXICAL_NEW_TARGET_CAPTURE);
+    }
+    ts.forEachChild(current, visit);
+  };
+  if (node.body) {
+    ts.forEachChild(node.body, visit);
+  }
+  return {
+    localNames,
+    capturedFromOuter,
+    capturedByDescendants
+  };
+}
+var ScopeMap = class {
+  constructor(parent) {
+    this.parent = parent;
+  }
+  parent;
+  map = /* @__PURE__ */ new Map();
+  get(name) {
+    return this.map.get(name) ?? this.parent?.get(name);
+  }
+  set(name, binding) {
+    this.map.set(name, binding);
+  }
+  has(name) {
+    return this.map.has(name) || (this.parent?.has(name) ?? false);
+  }
+  hasOwn(name) {
+    return this.map.has(name);
+  }
+  delete(name) {
+    if (this.map.has(name)) {
+      return this.map.delete(name);
+    }
+    return this.parent?.delete(name) ?? false;
+  }
+  keys() {
+    const all = /* @__PURE__ */ new Set();
+    let curr = this;
+    while (curr) {
+      for (const k of curr.map.keys()) {
+        all.add(k);
+      }
+      curr = curr.parent;
+    }
+    return Array.from(all);
+  }
+  entries() {
+    const all = /* @__PURE__ */ new Map();
+    let curr = this;
+    const scopes = [];
+    while (curr) {
+      scopes.unshift(curr);
+      curr = curr.parent;
+    }
+    for (const scope of scopes) {
+      for (const [k, v] of scope.map.entries()) {
+        all.set(k, v);
+      }
+    }
+    return Array.from(all.entries());
+  }
+};
+
+// src/lowering/expressions.ts
+import { OpCode, OperandKind, ConstantKind } from "@tsvm/shared";
+import ts2 from "typescript";
+function lowerConditionalExpression(self, conditionReg, whenTrue, whenFalse) {
+  const tempReg = self.createTempLocal("expr");
+  const trueBlock = self.fnBuilder.createBlock("expr_true");
+  const falseBlock = self.fnBuilder.createBlock("expr_false");
+  const endBlock = self.fnBuilder.createBlock("expr_end");
+  trueBlock.addPredecessor(self.currentBlock.id);
+  falseBlock.addPredecessor(self.currentBlock.id);
+  self.currentBlock.setTerminator({ kind: "branch", condition: conditionReg, targets: [trueBlock.id, falseBlock.id] });
+  self.fnBuilder.addBlock(self.currentBlock.build());
+  self.currentBlock = trueBlock;
+  const trueValue = whenTrue();
+  self.currentBlock.addInstruction(OpCode.StoreLocal, [
+    { kind: OperandKind.Register, value: tempReg },
+    { kind: OperandKind.Register, value: trueValue }
+  ]);
+  self.currentBlock.setTerminator({ kind: "jump", targets: [endBlock.id] });
+  endBlock.addPredecessor(self.currentBlock.id);
+  self.fnBuilder.addBlock(self.currentBlock.build());
+  self.currentBlock = falseBlock;
+  const falseValue = whenFalse();
+  self.currentBlock.addInstruction(OpCode.StoreLocal, [
+    { kind: OperandKind.Register, value: tempReg },
+    { kind: OperandKind.Register, value: falseValue }
+  ]);
+  self.currentBlock.setTerminator({ kind: "jump", targets: [endBlock.id] });
+  endBlock.addPredecessor(self.currentBlock.id);
+  self.fnBuilder.addBlock(self.currentBlock.build());
+  self.currentBlock = endBlock;
+  return self.loadFromLocal(tempReg);
+}
+function lowerNullishCoalesce(self, leftReg, rightExpr) {
+  const tempReg = self.createTempLocal("nullish");
+  self.currentBlock.addInstruction(OpCode.StoreLocal, [
+    { kind: OperandKind.Register, value: tempReg },
+    { kind: OperandKind.Register, value: leftReg }
+  ]);
+  const nullConst = self.emitConstant(ConstantKind.Null, null);
+  const undefConst = self.emitConstant(ConstantKind.Undefined, null);
+  const isNullReg = self.fnBuilder.allocRegister();
+  self.currentBlock.addInstruction(
+    OpCode.StrictEq,
+    [
+      { kind: OperandKind.Register, value: leftReg },
+      { kind: OperandKind.Register, value: nullConst }
+    ],
+    isNullReg
+  );
+  const rhsBlock = self.fnBuilder.createBlock("nullish_rhs");
+  const undefCheckBlock = self.fnBuilder.createBlock("nullish_undef");
+  const endBlock = self.fnBuilder.createBlock("nullish_end");
+  rhsBlock.addPredecessor(self.currentBlock.id);
+  undefCheckBlock.addPredecessor(self.currentBlock.id);
+  self.currentBlock.setTerminator({ kind: "branch", condition: isNullReg, targets: [rhsBlock.id, undefCheckBlock.id] });
+  self.fnBuilder.addBlock(self.currentBlock.build());
+  self.currentBlock = undefCheckBlock;
+  const isUndefReg = self.fnBuilder.allocRegister();
+  self.currentBlock.addInstruction(
+    OpCode.StrictEq,
+    [
+      { kind: OperandKind.Register, value: leftReg },
+      { kind: OperandKind.Register, value: undefConst }
+    ],
+    isUndefReg
+  );
+  rhsBlock.addPredecessor(self.currentBlock.id);
+  endBlock.addPredecessor(self.currentBlock.id);
+  self.currentBlock.setTerminator({ kind: "branch", condition: isUndefReg, targets: [rhsBlock.id, endBlock.id] });
+  self.fnBuilder.addBlock(self.currentBlock.build());
+  self.currentBlock = rhsBlock;
+  const rightReg = visitExpression(self, rightExpr);
+  self.currentBlock.addInstruction(OpCode.StoreLocal, [
+    { kind: OperandKind.Register, value: tempReg },
+    { kind: OperandKind.Register, value: rightReg }
+  ]);
+  self.currentBlock.setTerminator({ kind: "jump", targets: [endBlock.id] });
+  endBlock.addPredecessor(self.currentBlock.id);
+  self.fnBuilder.addBlock(self.currentBlock.build());
+  self.currentBlock = endBlock;
+  return self.loadFromLocal(tempReg);
+}
+function lowerTemplateExpression(self, expr) {
+  let accReg = self.emitConstant(ConstantKind.String, expr.head.text);
+  for (const span of expr.templateSpans) {
+    const valueReg = visitExpression(self, span.expression);
+    const combinedValue = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(
+      OpCode.Add,
+      [
+        { kind: OperandKind.Register, value: accReg },
+        { kind: OperandKind.Register, value: valueReg }
+      ],
+      combinedValue
+    );
+    accReg = combinedValue;
+    if (span.literal.text.length > 0) {
+      const literalReg = self.emitConstant(ConstantKind.String, span.literal.text);
+      const combinedLiteral = self.fnBuilder.allocRegister();
+      self.currentBlock.addInstruction(
+        OpCode.Add,
+        [
+          { kind: OperandKind.Register, value: accReg },
+          { kind: OperandKind.Register, value: literalReg }
+        ],
+        combinedLiteral
+      );
+      accReg = combinedLiteral;
+    }
+  }
+  return accReg;
+}
+function lowerNestedFunctionNode(self, expr, explicitName) {
+  return self.lowerNestedFunctionLike(expr, explicitName);
+}
+function visitExpression(self, expr) {
+  expr = self.normalizeExpression(expr);
+  if (ts2.isNumericLiteral(expr)) {
+    return self.emitConstant(ConstantKind.Number, Number.parseFloat(expr.text));
+  }
+  if (ts2.isStringLiteral(expr) || ts2.isNoSubstitutionTemplateLiteral(expr)) {
+    return self.emitConstant(ConstantKind.String, expr.text);
+  }
+  if (ts2.isBigIntLiteral(expr)) {
+    const bigintGlobalReg = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(
+      OpCode.LoadGlobal,
+      [{ kind: OperandKind.Register, value: self.emitConstant(ConstantKind.String, "BigInt") }],
+      bigintGlobalReg
+    );
+    const valReg = self.emitConstant(ConstantKind.String, expr.text);
+    const resReg = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(
+      OpCode.Call,
+      [
+        { kind: OperandKind.Register, value: bigintGlobalReg },
+        { kind: OperandKind.Register, value: valReg }
+      ],
+      resReg
+    );
+    return resReg;
+  }
+  if (ts2.isRegularExpressionLiteral(expr)) {
+    const rawText = expr.text;
+    const lastSlashIndex = rawText.lastIndexOf("/");
+    const pattern = rawText.slice(1, lastSlashIndex);
+    const flags = rawText.slice(lastSlashIndex + 1);
+    const objectGlobalReg = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(
+      OpCode.LoadGlobal,
+      [{ kind: OperandKind.Register, value: self.emitConstant(ConstantKind.String, "RegExp") }],
+      objectGlobalReg
+    );
+    const patternReg = self.emitConstant(ConstantKind.String, pattern);
+    const flagsReg = self.emitConstant(ConstantKind.String, flags);
+    const resReg = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(
+      OpCode.New,
+      [
+        { kind: OperandKind.Register, value: objectGlobalReg },
+        { kind: OperandKind.Register, value: patternReg },
+        { kind: OperandKind.Register, value: flagsReg }
+      ],
+      resReg
+    );
+    return resReg;
+  }
+  if (ts2.isTemplateExpression(expr)) {
+    return lowerTemplateExpression(self, expr);
+  }
+  if (ts2.isAwaitExpression(expr)) {
+    if (!self.isAsyncFunction) {
+      self.failUnsupported(expr, "await outside async function is not supported");
+    }
+    const awaitedSourceReg = visitExpression(self, expr.expression);
+    const awaitedValueReg = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(OpCode.Await, [{ kind: OperandKind.Register, value: awaitedSourceReg }], awaitedValueReg);
+    return awaitedValueReg;
+  }
+  if (ts2.isYieldExpression(expr)) {
+    if (!self.isGenerator) {
+      self.failUnsupported(expr, "yield outside generator is not supported");
+    }
+    const yieldedValueReg = expr.expression ? visitExpression(self, expr.expression) : self.emitConstant(ConstantKind.Undefined, null);
+    const resReg = self.fnBuilder.allocRegister();
+    if (expr.asteriskToken) {
+      self.currentBlock.addInstruction(OpCode.YieldStar, [{ kind: OperandKind.Register, value: yieldedValueReg }], resReg);
+    } else {
+      self.currentBlock.addInstruction(OpCode.Yield, [{ kind: OperandKind.Register, value: yieldedValueReg }], resReg);
+    }
+    return resReg;
+  }
+  if (expr.kind === ts2.SyntaxKind.NullKeyword) return self.emitConstant(ConstantKind.Null, null);
+  if (expr.kind === ts2.SyntaxKind.TrueKeyword) return self.emitConstant(ConstantKind.Boolean, true);
+  if (expr.kind === ts2.SyntaxKind.FalseKeyword) return self.emitConstant(ConstantKind.Boolean, false);
+  if (expr.kind === ts2.SyntaxKind.ThisKeyword) {
+    if (ts2.isArrowFunction(self.node) && (self.scope.has(LEXICAL_THIS_CAPTURE) || self.outerCaptureBindings.has(LEXICAL_THIS_CAPTURE))) {
+      return self.resolveLexicalCapture(
+        LEXICAL_THIS_CAPTURE,
+        expr,
+        "lexical this in arrow function requires an enclosing function context"
+      );
+    }
+    const thisReg = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(OpCode.LoadThis, [], thisReg);
+    return thisReg;
+  }
+  if (ts2.isMetaProperty(expr)) {
+    if (expr.keywordToken === ts2.SyntaxKind.NewKeyword && expr.name.text === "target") {
+      if (ts2.isArrowFunction(self.node) && (self.scope.has(LEXICAL_NEW_TARGET_CAPTURE) || self.outerCaptureBindings.has(LEXICAL_NEW_TARGET_CAPTURE))) {
+        return self.resolveLexicalCapture(
+          LEXICAL_NEW_TARGET_CAPTURE,
+          expr,
+          "lexical new.target in arrow function requires an enclosing function context"
+        );
+      }
+      const newTargetReg = self.fnBuilder.allocRegister();
+      self.currentBlock.addInstruction(OpCode.LoadNewTarget, [], newTargetReg);
+      return newTargetReg;
+    }
+    self.failUnsupported(expr, "meta property is not supported");
+  }
+  if (ts2.isIdentifier(expr)) {
+    return self.resolveVar(expr.text);
+  }
+  if (ts2.isConditionalExpression(expr)) {
+    const conditionReg = visitExpression(self, expr.condition);
+    return lowerConditionalExpression(
+      self,
+      conditionReg,
+      () => visitExpression(self, expr.whenTrue),
+      () => visitExpression(self, expr.whenFalse)
+    );
+  }
+  if (ts2.isBinaryExpression(expr)) {
+    if (expr.operatorToken.kind === ts2.SyntaxKind.AmpersandAmpersandToken || expr.operatorToken.kind === ts2.SyntaxKind.BarBarToken || expr.operatorToken.kind === ts2.SyntaxKind.QuestionQuestionToken) {
+      const leftReg2 = visitExpression(self, expr.left);
+      if (expr.operatorToken.kind === ts2.SyntaxKind.AmpersandAmpersandToken) {
+        return lowerConditionalExpression(
+          self,
+          leftReg2,
+          () => visitExpression(self, expr.right),
+          () => leftReg2
+        );
+      }
+      if (expr.operatorToken.kind === ts2.SyntaxKind.BarBarToken) {
+        return lowerConditionalExpression(
+          self,
+          leftReg2,
+          () => leftReg2,
+          () => visitExpression(self, expr.right)
+        );
+      }
+      return lowerNullishCoalesce(self, leftReg2, expr.right);
+    }
+    if (expr.operatorToken.kind === ts2.SyntaxKind.EqualsToken) {
+      const valueReg = visitExpression(self, expr.right);
+      self.storeValue(expr.left, valueReg);
+      return valueReg;
+    }
+    if (expr.operatorToken.kind === ts2.SyntaxKind.InKeyword && ts2.isPrivateIdentifier(expr.left)) {
+      const leftReg2 = self.resolvePrivateIdentifierRegister(expr.left);
+      const rightReg2 = visitExpression(self, expr.right);
+      const resReg2 = self.fnBuilder.allocRegister();
+      self.currentBlock.addInstruction(
+        OpCode.PrivateIn,
+        [
+          { kind: OperandKind.Register, value: rightReg2 },
+          { kind: OperandKind.Register, value: leftReg2 }
+        ],
+        resReg2
+      );
+      return resReg2;
+    }
+    const leftReg = visitExpression(self, expr.left);
+    const rightReg = visitExpression(self, expr.right);
+    const resReg = self.fnBuilder.allocRegister();
+    const opMap = {
+      [ts2.SyntaxKind.PlusToken]: OpCode.Add,
+      [ts2.SyntaxKind.MinusToken]: OpCode.Sub,
+      [ts2.SyntaxKind.AsteriskToken]: OpCode.Mul,
+      [ts2.SyntaxKind.SlashToken]: OpCode.Div,
+      [ts2.SyntaxKind.PercentToken]: OpCode.Mod,
+      [ts2.SyntaxKind.LessThanLessThanToken]: OpCode.Shl,
+      [ts2.SyntaxKind.GreaterThanGreaterThanToken]: OpCode.Shr,
+      [ts2.SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: OpCode.UShr,
+      [ts2.SyntaxKind.BarToken]: OpCode.BitOr,
+      [ts2.SyntaxKind.AmpersandToken]: OpCode.BitAnd,
+      [ts2.SyntaxKind.CaretToken]: OpCode.BitXor,
+      [ts2.SyntaxKind.LessThanToken]: OpCode.Lt,
+      [ts2.SyntaxKind.GreaterThanToken]: OpCode.Gt,
+      [ts2.SyntaxKind.LessThanEqualsToken]: OpCode.LtEq,
+      [ts2.SyntaxKind.GreaterThanEqualsToken]: OpCode.GtEq,
+      [ts2.SyntaxKind.EqualsEqualsToken]: OpCode.Eq,
+      [ts2.SyntaxKind.EqualsEqualsEqualsToken]: OpCode.StrictEq,
+      [ts2.SyntaxKind.ExclamationEqualsToken]: OpCode.Eq,
+      [ts2.SyntaxKind.ExclamationEqualsEqualsToken]: OpCode.StrictEq,
+      [ts2.SyntaxKind.InKeyword]: OpCode.In,
+      [ts2.SyntaxKind.InstanceOfKeyword]: OpCode.InstanceOf
+    };
+    const isCompound = expr.operatorToken.kind >= ts2.SyntaxKind.PlusEqualsToken && expr.operatorToken.kind <= ts2.SyntaxKind.CaretEqualsToken;
+    if (isCompound) {
+      const cmpMap = {
+        [ts2.SyntaxKind.PlusEqualsToken]: OpCode.Add,
+        [ts2.SyntaxKind.MinusEqualsToken]: OpCode.Sub,
+        [ts2.SyntaxKind.AsteriskEqualsToken]: OpCode.Mul,
+        [ts2.SyntaxKind.SlashEqualsToken]: OpCode.Div,
+        [ts2.SyntaxKind.PercentEqualsToken]: OpCode.Mod,
+        [ts2.SyntaxKind.LessThanLessThanEqualsToken]: OpCode.Shl,
+        [ts2.SyntaxKind.GreaterThanGreaterThanEqualsToken]: OpCode.Shr,
+        [ts2.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken]: OpCode.UShr,
+        [ts2.SyntaxKind.AmpersandEqualsToken]: OpCode.BitAnd,
+        [ts2.SyntaxKind.BarEqualsToken]: OpCode.BitOr,
+        [ts2.SyntaxKind.CaretEqualsToken]: OpCode.BitXor
+      };
+      const opc = cmpMap[expr.operatorToken.kind] || OpCode.Add;
+      const leftValueReg = self.readValue(expr.left);
+      self.currentBlock.addInstruction(
+        opc,
+        [
+          { kind: OperandKind.Register, value: leftValueReg },
+          { kind: OperandKind.Register, value: rightReg }
+        ],
+        resReg
+      );
+      self.storeValue(expr.left, resReg);
+      return resReg;
+    }
+    if (opMap[expr.operatorToken.kind]) {
+      self.currentBlock.addInstruction(
+        opMap[expr.operatorToken.kind],
+        [
+          { kind: OperandKind.Register, value: leftReg },
+          { kind: OperandKind.Register, value: rightReg }
+        ],
+        resReg
+      );
+      if (expr.operatorToken.kind === ts2.SyntaxKind.ExclamationEqualsToken || expr.operatorToken.kind === ts2.SyntaxKind.ExclamationEqualsEqualsToken) {
+        const notReg = self.fnBuilder.allocRegister();
+        self.currentBlock.addInstruction(OpCode.Not, [{ kind: OperandKind.Register, value: resReg }], notReg);
+        return notReg;
+      }
+      return resReg;
+    }
+  }
+  if (ts2.isPropertyAccessExpression(expr)) {
+    if (expr.expression.kind === ts2.SyntaxKind.SuperKeyword) {
+      const propReg2 = self.emitConstant(ConstantKind.String, expr.name.text);
+      const resReg2 = self.fnBuilder.allocRegister();
+      self.currentBlock.addInstruction(OpCode.SuperPropGet, [{ kind: OperandKind.Register, value: propReg2 }], resReg2);
+      return resReg2;
+    }
+    const objReg = visitExpression(self, expr.expression);
+    const resReg = self.fnBuilder.allocRegister();
+    if (ts2.isPrivateIdentifier(expr.name)) {
+      const privateKeyReg = self.resolvePrivateIdentifierRegister(expr.name);
+      self.currentBlock.addInstruction(
+        OpCode.PrivateGet,
+        [
+          { kind: OperandKind.Register, value: objReg },
+          { kind: OperandKind.Register, value: privateKeyReg }
+        ],
+        resReg
+      );
+      return resReg;
+    }
+    const propReg = self.emitConstant(ConstantKind.String, expr.name.text);
+    self.currentBlock.addInstruction(
+      OpCode.PropGet,
+      [
+        { kind: OperandKind.Register, value: objReg },
+        { kind: OperandKind.Register, value: propReg }
+      ],
+      resReg
+    );
+    return resReg;
+  }
+  if (ts2.isElementAccessExpression(expr)) {
+    if (!expr.argumentExpression) {
+      self.failUnsupported(expr, "Element access requires an index expression");
+    }
+    const objReg = visitExpression(self, expr.expression);
+    const indexReg = visitExpression(self, expr.argumentExpression);
+    const resReg = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(
+      OpCode.ComputedGet,
+      [
+        { kind: OperandKind.Register, value: objReg },
+        { kind: OperandKind.Register, value: indexReg }
+      ],
+      resReg
+    );
+    return resReg;
+  }
+  if (ts2.isArrayLiteralExpression(expr)) {
+    const arrayReg = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(OpCode.ArrayNew, [], arrayReg);
+    const indexLocal = self.createTempLocal("array_index");
+    const zeroReg = self.emitConstant(ConstantKind.Number, 0);
+    const oneReg = self.emitConstant(ConstantKind.Number, 1);
+    const lengthKeyReg = self.emitConstant(ConstantKind.String, "length");
+    self.storeToLocal(indexLocal, zeroReg);
+    expr.elements.forEach((element) => {
+      if (ts2.isOmittedExpression(element)) {
+        const currentIndexReg2 = self.loadFromLocal(indexLocal);
+        const nextIndexReg2 = self.fnBuilder.allocRegister();
+        self.currentBlock.addInstruction(
+          OpCode.Add,
+          [
+            { kind: OperandKind.Register, value: currentIndexReg2 },
+            { kind: OperandKind.Register, value: oneReg }
+          ],
+          nextIndexReg2
+        );
+        self.storeToLocal(indexLocal, nextIndexReg2);
+        return;
+      }
+      if (ts2.isSpreadElement(element)) {
+        const currentIndexReg2 = self.loadFromLocal(indexLocal);
+        const spreadReg = visitExpression(self, element.expression);
+        self.emitSpreadIntoArray(arrayReg, spreadReg, currentIndexReg2, indexLocal);
+        return;
+      }
+      const currentIndexReg = self.loadFromLocal(indexLocal);
+      const valueReg = visitExpression(self, element);
+      self.currentBlock.addInstruction(OpCode.ComputedSet, [
+        { kind: OperandKind.Register, value: arrayReg },
+        { kind: OperandKind.Register, value: currentIndexReg },
+        { kind: OperandKind.Register, value: valueReg }
+      ]);
+      const nextIndexReg = self.fnBuilder.allocRegister();
+      self.currentBlock.addInstruction(
+        OpCode.Add,
+        [
+          { kind: OperandKind.Register, value: currentIndexReg },
+          { kind: OperandKind.Register, value: oneReg }
+        ],
+        nextIndexReg
+      );
+      self.storeToLocal(indexLocal, nextIndexReg);
+    });
+    const finalLengthReg = self.loadFromLocal(indexLocal);
+    self.currentBlock.addInstruction(OpCode.PropSet, [
+      { kind: OperandKind.Register, value: arrayReg },
+      { kind: OperandKind.Register, value: lengthKeyReg },
+      { kind: OperandKind.Register, value: finalLengthReg }
+    ]);
+    return arrayReg;
+  }
+  if (ts2.isObjectLiteralExpression(expr)) {
+    const objectReg = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(OpCode.ObjectNew, [], objectReg);
+    for (const property of expr.properties) {
+      if (ts2.isPropertyAssignment(property)) {
+        const valueReg = visitExpression(self, property.initializer);
+        if (ts2.isComputedPropertyName(property.name)) {
+          const nameReg = visitExpression(self, property.name.expression);
+          self.emitObjectPropertyAssignment(objectReg, nameReg, valueReg, true);
+        } else {
+          const propName = self.getPropertyNameText(property.name);
+          const nameReg = self.emitConstant(ConstantKind.String, propName);
+          self.emitObjectPropertyAssignment(objectReg, nameReg, valueReg);
+        }
+        continue;
+      }
+      if (ts2.isShorthandPropertyAssignment(property)) {
+        const nameReg = self.emitConstant(ConstantKind.String, property.name.text);
+        const valueReg = self.resolveVar(property.name.text);
+        self.emitObjectPropertyAssignment(objectReg, nameReg, valueReg);
+        continue;
+      }
+      if (ts2.isMethodDeclaration(property)) {
+        const valueReg = lowerNestedFunctionNode(self, property);
+        if (ts2.isComputedPropertyName(property.name)) {
+          const nameReg = visitExpression(self, property.name.expression);
+          self.emitObjectPropertyAssignment(objectReg, nameReg, valueReg, true);
+        } else {
+          const nameReg = self.emitConstant(ConstantKind.String, self.getPropertyNameText(property.name));
+          self.emitObjectPropertyAssignment(objectReg, nameReg, valueReg);
+        }
+        continue;
+      }
+      if (ts2.isSpreadAssignment(property)) {
+        const valueReg = visitExpression(self, property.expression);
+        self.emitSpreadInto(objectReg, valueReg);
+        continue;
+      }
+      if (ts2.isGetAccessor(property) || ts2.isSetAccessor(property)) {
+        const valueReg = lowerNestedFunctionNode(self, property);
+        const nameReg = ts2.isComputedPropertyName(property.name) ? visitExpression(self, property.name.expression) : self.emitConstant(ConstantKind.String, self.getPropertyNameText(property.name));
+        const objectGlobalReg = self.fnBuilder.allocRegister();
+        self.currentBlock.addInstruction(
+          OpCode.LoadGlobal,
+          [{ kind: OperandKind.Register, value: self.emitConstant(ConstantKind.String, "Object") }],
+          objectGlobalReg
+        );
+        const descriptorReg = self.fnBuilder.allocRegister();
+        self.currentBlock.addInstruction(OpCode.ObjectNew, [], descriptorReg);
+        const getPropReg = self.emitConstant(ConstantKind.String, ts2.isGetAccessor(property) ? "get" : "set");
+        self.emitObjectPropertyAssignment(descriptorReg, getPropReg, valueReg);
+        const trueReg = self.emitConstant(ConstantKind.Boolean, true);
+        self.emitObjectPropertyAssignment(descriptorReg, self.emitConstant(ConstantKind.String, "configurable"), trueReg);
+        self.emitObjectPropertyAssignment(descriptorReg, self.emitConstant(ConstantKind.String, "enumerable"), trueReg);
+        self.currentBlock.addInstruction(
+          OpCode.CallMethod,
+          [
+            { kind: OperandKind.Register, value: objectGlobalReg },
+            { kind: OperandKind.Register, value: self.emitConstant(ConstantKind.String, "defineProperty") },
+            { kind: OperandKind.Register, value: objectReg },
+            { kind: OperandKind.Register, value: nameReg },
+            { kind: OperandKind.Register, value: descriptorReg }
+          ],
+          self.fnBuilder.allocRegister()
+        );
+        continue;
+      }
+      self.failUnsupported(property, "Unsupported object literal property kind");
+    }
+    return objectReg;
+  }
+  if (ts2.isCallExpression(expr)) {
+    const resReg = self.fnBuilder.allocRegister();
+    const hasSpread = expr.arguments.some((arg) => ts2.isSpreadElement(arg));
+    if (hasSpread) {
+      const argArrayReg = self.materializeArgumentArray(expr.arguments);
+      if (expr.expression.kind === ts2.SyntaxKind.SuperKeyword) {
+        self.currentBlock.addInstruction(OpCode.SuperCallWithArray, [{ kind: OperandKind.Register, value: argArrayReg }], resReg);
+        if (self.instanceFieldsToInitialize) {
+          self.emitInstanceFieldInitializers(self.instanceFieldsToInitialize);
+        }
+        return resReg;
+      }
+      if (ts2.isPropertyAccessExpression(expr.expression)) {
+        if (expr.expression.expression.kind === ts2.SyntaxKind.SuperKeyword) {
+          const propReg2 = self.emitConstant(ConstantKind.String, expr.expression.name.text);
+          const fnReg = self.fnBuilder.allocRegister();
+          self.currentBlock.addInstruction(OpCode.SuperPropGet, [{ kind: OperandKind.Register, value: propReg2 }], fnReg);
+          const applyReg = self.emitConstant(ConstantKind.String, "apply");
+          const thisReg = self.fnBuilder.allocRegister();
+          self.currentBlock.addInstruction(OpCode.LoadThis, [], thisReg);
+          self.currentBlock.addInstruction(
+            OpCode.CallMethod,
+            [
+              { kind: OperandKind.Register, value: fnReg },
+              { kind: OperandKind.Register, value: applyReg },
+              { kind: OperandKind.Register, value: thisReg },
+              { kind: OperandKind.Register, value: argArrayReg }
+            ],
+            resReg
+          );
+          return resReg;
+        }
+        const objReg = visitExpression(self, expr.expression.expression);
+        const propReg = self.emitConstant(ConstantKind.String, expr.expression.name.text);
+        self.currentBlock.addInstruction(
+          OpCode.CallMethodWithArray,
+          [
+            { kind: OperandKind.Register, value: objReg },
+            { kind: OperandKind.Register, value: propReg },
+            { kind: OperandKind.Register, value: argArrayReg }
+          ],
+          resReg
+        );
+        return resReg;
+      }
+      const calleeReg = visitExpression(self, expr.expression);
+      self.currentBlock.addInstruction(
+        OpCode.CallWithArray,
+        [
+          { kind: OperandKind.Register, value: calleeReg },
+          { kind: OperandKind.Register, value: argArrayReg }
+        ],
+        resReg
+      );
+      return resReg;
+    }
+    const args = expr.arguments.map((a) => visitExpression(self, a));
+    if (expr.expression.kind === ts2.SyntaxKind.SuperKeyword) {
+      const ops = args.map((a) => ({ kind: OperandKind.Register, value: a }));
+      self.currentBlock.addInstruction(OpCode.SuperCall, ops, resReg);
+      if (self.instanceFieldsToInitialize) {
+        self.emitInstanceFieldInitializers(self.instanceFieldsToInitialize);
+      }
+      return resReg;
+    }
+    if (ts2.isPropertyAccessExpression(expr.expression)) {
+      if (expr.expression.expression.kind === ts2.SyntaxKind.SuperKeyword) {
+        const propReg2 = self.emitConstant(ConstantKind.String, expr.expression.name.text);
+        const fnReg = self.fnBuilder.allocRegister();
+        self.currentBlock.addInstruction(OpCode.SuperPropGet, [{ kind: OperandKind.Register, value: propReg2 }], fnReg);
+        const callReg = self.emitConstant(ConstantKind.String, "call");
+        const thisReg = self.fnBuilder.allocRegister();
+        self.currentBlock.addInstruction(OpCode.LoadThis, [], thisReg);
+        const ops2 = [
+          { kind: OperandKind.Register, value: fnReg },
+          { kind: OperandKind.Register, value: callReg },
+          { kind: OperandKind.Register, value: thisReg },
+          ...args.map((a) => ({ kind: OperandKind.Register, value: a }))
+        ];
+        self.currentBlock.addInstruction(OpCode.CallMethod, ops2, resReg);
+        return resReg;
+      }
+      const objReg = visitExpression(self, expr.expression.expression);
+      const propReg = self.emitConstant(ConstantKind.String, expr.expression.name.text);
+      const ops = [
+        { kind: OperandKind.Register, value: objReg },
+        { kind: OperandKind.Register, value: propReg },
+        ...args.map((a) => ({ kind: OperandKind.Register, value: a }))
+      ];
+      self.currentBlock.addInstruction(OpCode.CallMethod, ops, resReg);
+    } else {
+      const calleeReg = visitExpression(self, expr.expression);
+      const ops = [
+        { kind: OperandKind.Register, value: calleeReg },
+        ...args.map((a) => ({ kind: OperandKind.Register, value: a }))
+      ];
+      self.currentBlock.addInstruction(OpCode.Call, ops, resReg);
+    }
+    return resReg;
+  }
+  if (ts2.isNewExpression(expr)) {
+    const calleeReg = visitExpression(self, expr.expression);
+    const resReg = self.fnBuilder.allocRegister();
+    const argsList = expr.arguments ? [...expr.arguments] : [];
+    if (argsList.some((arg) => ts2.isSpreadElement(arg))) {
+      const argArrayReg = self.materializeArgumentArray(argsList);
+      self.currentBlock.addInstruction(
+        OpCode.NewWithArray,
+        [
+          { kind: OperandKind.Register, value: calleeReg },
+          { kind: OperandKind.Register, value: argArrayReg }
+        ],
+        resReg
+      );
+      return resReg;
+    }
+    const args = argsList.map((arg) => visitExpression(self, arg));
+    const ops = [
+      { kind: OperandKind.Register, value: calleeReg },
+      ...args.map((arg) => ({ kind: OperandKind.Register, value: arg }))
+    ];
+    self.currentBlock.addInstruction(OpCode.New, ops, resReg);
+    return resReg;
+  }
+  if (ts2.isArrowFunction(expr) || ts2.isFunctionExpression(expr)) {
+    return lowerNestedFunctionNode(self, expr);
+  }
+  if (ts2.isClassExpression(expr)) {
+    return self.lowerClassLike(expr, expr.name?.text);
+  }
+  if (ts2.isPostfixUnaryExpression(expr)) {
+    if (expr.operator === ts2.SyntaxKind.PlusPlusToken) {
+      if (ts2.isIdentifier(expr.operand)) {
+        const vReg = self.resolveVar(expr.operand.text);
+        const oneReg = self.emitConstant(ConstantKind.Number, 1);
+        const resReg = self.fnBuilder.allocRegister();
+        self.currentBlock.addInstruction(
+          OpCode.Add,
+          [
+            { kind: OperandKind.Register, value: vReg },
+            { kind: OperandKind.Register, value: oneReg }
+          ],
+          resReg
+        );
+        self.storeValue(expr.operand, resReg);
+        return vReg;
+      }
+    }
+  }
+  if (ts2.isPrefixUnaryExpression(expr)) {
+    const operandReg = visitExpression(self, expr.operand);
+    const resReg = self.fnBuilder.allocRegister();
+    if (expr.operator === ts2.SyntaxKind.ExclamationToken) {
+      self.currentBlock.addInstruction(OpCode.Not, [{ kind: OperandKind.Register, value: operandReg }], resReg);
+    } else if (expr.operator === ts2.SyntaxKind.MinusToken) {
+      self.currentBlock.addInstruction(OpCode.Neg, [{ kind: OperandKind.Register, value: operandReg }], resReg);
+    } else if (expr.operator === ts2.SyntaxKind.TildeToken) {
+      const notReg = self.fnBuilder.allocRegister();
+      self.currentBlock.addInstruction(OpCode.Not, [{ kind: OperandKind.Register, value: operandReg }], notReg);
+      self.currentBlock.addInstruction(
+        OpCode.BitXor,
+        [
+          { kind: OperandKind.Register, value: operandReg },
+          { kind: OperandKind.Register, value: notReg }
+        ],
+        resReg
+      );
+    } else {
+      self.failUnsupported(expr, "Unsupported prefix unary operator");
+    }
+    return resReg;
+  }
+  if (ts2.isTypeOfExpression(expr)) {
+    const operandReg = visitExpression(self, expr.expression);
+    const resReg = self.fnBuilder.allocRegister();
+    self.currentBlock.addInstruction(OpCode.TypeOf, [{ kind: OperandKind.Register, value: operandReg }], resReg);
+    return resReg;
+  }
+  if (ts2.isDeleteExpression(expr)) {
+    if (ts2.isPropertyAccessExpression(expr.expression)) {
+      const objReg = visitExpression(self, expr.expression.expression);
+      const propReg = self.emitConstant(ConstantKind.String, expr.expression.name.text);
+      const resReg = self.fnBuilder.allocRegister();
+      self.currentBlock.addInstruction(OpCode.Delete, [
+        { kind: OperandKind.Register, value: objReg },
+        { kind: OperandKind.Register, value: propReg }
+      ]);
+      self.currentBlock.addInstruction(
+        OpCode.LoadConst,
+        [{ kind: OperandKind.ConstantIndex, value: self.modBuilder.addConstant(ConstantKind.Boolean, true) }],
+        resReg
+      );
+      return resReg;
+    }
+    if (ts2.isElementAccessExpression(expr.expression)) {
+      if (!expr.expression.argumentExpression) {
+        self.failUnsupported(expr.expression, "Element access requires an index expression");
+      }
+      const objReg = visitExpression(self, expr.expression.expression);
+      const propReg = visitExpression(self, expr.expression.argumentExpression);
+      const resReg = self.fnBuilder.allocRegister();
+      self.currentBlock.addInstruction(OpCode.Delete, [
+        { kind: OperandKind.Register, value: objReg },
+        { kind: OperandKind.Register, value: propReg }
+      ]);
+      self.currentBlock.addInstruction(
+        OpCode.LoadConst,
+        [{ kind: OperandKind.ConstantIndex, value: self.modBuilder.addConstant(ConstantKind.Boolean, true) }],
+        resReg
+      );
+      return resReg;
+    }
+    self.failUnsupported(expr, "Unsupported delete target");
+  }
+  self.failUnsupported(expr);
+}
+
+// src/builder.ts
+var ASTLowering = class _ASTLowering {
+  constructor(modBuilder, node, options) {
+    this.modBuilder = modBuilder;
+    this.node = node;
+    this.functionId = modBuilder.getNextFunctionId();
+    this.fnBuilder = new IRFunctionBuilder(this.functionId, options.name, IRType.Any);
+    this.sourceFile = node.getSourceFile();
+    this.capturedLocals = options.analysis.capturedByDescendants;
+    this.privateIdentifierBindings = options.privateIdentifierBindings ?? /* @__PURE__ */ new Map();
+    this.instanceFieldsToInitialize = options.instanceFieldsToInitialize;
+    if (options.isExported) {
+      this.fnBuilder.addAttribute(FunctionAttribute.Exported);
+    }
+    if (options.isNested) {
+      this.fnBuilder.addAttribute(FunctionAttribute.Nested);
+    }
+    for (const attribute of options.attributes ?? []) {
+      this.fnBuilder.addAttribute(attribute);
+    }
+    this.isAsyncFunction = !!this.node.modifiers?.some((modifier) => modifier.kind === ts3.SyntaxKind.AsyncKeyword) || "asteriskToken" in this.node && !!this.node.asteriskToken && this.node.name?.text === "async" || (options.attributes ?? []).includes(FunctionAttribute.Async);
+    this.isGenerator = "asteriskToken" in this.node && !!this.node.asteriskToken;
+    this.currentBlock = this.fnBuilder.createBlock("entry");
+    options.analysis.capturedFromOuter.forEach((name, index) => {
+      this.outerCaptureBindings.set(name, index);
+      this.fnBuilder.addCapturedVariable(name);
+    });
+    const isThisParameter = (param) => ts3.isIdentifier(param.name) && param.name.text === "this";
+    let runtimeParamIndex = 0;
+    node.parameters.forEach((param, index) => {
+      if (isThisParameter(param)) {
+        return;
+      }
+      const isPlainIdentifier = ts3.isIdentifier(param.name) && !param.dotDotDotToken && !param.initializer;
+      const paramName = isPlainIdentifier ? param.name.text : `$param_${runtimeParamIndex}`;
+      const reg = this.fnBuilder.addParam(paramName, IRType.Any, !!param.dotDotDotToken);
+      if (isPlainIdentifier && ts3.isIdentifier(param.name)) {
+        this.scope.set(param.name.text, { register: reg, boxed: this.capturedLocals.has(param.name.text) });
+      } else {
+        this.pendingParameterBindings.push({ param, register: reg });
+      }
+      runtimeParamIndex++;
+    });
+    this.boxCapturedParameters();
+    this.lowerPendingParameterBindings();
+    this.initializeLexicalSemanticCaptures(options.analysis);
+    options.prologueEmitter?.(this);
+    if (node.body) {
+      if (ts3.isBlock(node.body)) {
+        this.visitStatement(node.body);
+      } else {
+        const valueReg = this.visitExpression(node.body);
+        this.currentBlock.setTerminator({ kind: "return", targets: [], returnValue: valueReg });
+      }
+    }
+    if (this.shouldEmitFallthroughReturn()) {
+      const undefConst = this.modBuilder.addConstant(ConstantKind2.Undefined, null);
+      const rRet = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(OpCode2.LoadConst, [{ kind: OperandKind2.ConstantIndex, value: undefConst }], rRet);
+      this.currentBlock.setTerminator({ kind: "return", targets: [], returnValue: rRet });
+    }
+    if (!this.isSyntheticDeadBlock(this.currentBlock)) {
+      this.fnBuilder.addBlock(this.currentBlock.build());
+    }
+    this.modBuilder.addFunction(this.fnBuilder.build(options.isVirtualized, options.isExported));
+  }
+  modBuilder;
+  node;
+  fnBuilder;
+  currentBlock;
+  scope = new ScopeMap();
+  functionId;
+  nestedFunctionCount = 0;
+  tempLocalCount = 0;
+  sourceFile;
+  capturedLocals;
+  outerCaptureBindings = /* @__PURE__ */ new Map();
+  breakTargets = [];
+  continueTargets = [];
+  finallyContexts = [];
+  throwPassthroughFinallyDepth = 0;
+  pendingParameterBindings = [];
+  isAsyncFunction;
+  isGenerator;
+  privateIdentifierBindings;
+  instanceFieldsToInitialize;
+  failUnsupported(node, detail) {
+    const kind = ts3.SyntaxKind[node.kind];
+    const snippet = node.getText(this.sourceFile).replace(/\s+/g, " ").slice(0, 80);
+    const { line, character } = this.sourceFile.getLineAndCharacterOfPosition(node.getStart(this.sourceFile));
+    const message = detail ? `${kind} (${detail})` : kind;
+    throw new Error(
+      `Unsupported AST in IR builder: ${message} at ${this.sourceFile.fileName}:${line + 1}:${character + 1} near "${snippet}"`
+    );
+  }
+  isSyntheticDeadBlock(block) {
+    const label = block.label;
+    const syntheticLabel = label === "unreachable" || label === "after_break" || label === "after_continue";
+    return syntheticLabel && block.getInstructionCount() === 0 && (block.getTerminatorKind() === void 0 || block.getTerminatorKind() === "unreachable") && this.fnBuilder.getBlockCount() > 0;
+  }
+  shouldEmitFallthroughReturn() {
+    if (this.isSyntheticDeadBlock(this.currentBlock)) {
+      return false;
+    }
+    const termKind = this.currentBlock.getTerminatorKind();
+    return termKind === void 0 || termKind === "unreachable";
+  }
+  enterBreakTarget(target) {
+    this.breakTargets.push(target);
+  }
+  leaveBreakTarget() {
+    this.breakTargets.pop();
+  }
+  enterContinueTarget(target) {
+    this.continueTargets.push(target);
+  }
+  leaveContinueTarget() {
+    this.continueTargets.pop();
+  }
+  emitJumpAndAdvance(targetBlockId, nextLabel) {
+    this.currentBlock.setTerminator({ kind: "jump", targets: [targetBlockId] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = this.fnBuilder.createBlock(nextLabel);
+  }
+  emitConstant(kind, value) {
+    const idx = this.modBuilder.addConstant(kind, value);
+    const reg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(OpCode2.LoadConst, [{ kind: OperandKind2.ConstantIndex, value: idx }], reg);
+    return reg;
+  }
+  storeToLocal(localReg, valueReg) {
+    this.currentBlock.addInstruction(OpCode2.StoreLocal, [
+      { kind: OperandKind2.Register, value: localReg },
+      { kind: OperandKind2.Register, value: valueReg }
+    ]);
+  }
+  boxCapturedParameters() {
+    for (const [name, binding] of this.scope.entries()) {
+      if (binding.boxed) {
+        this.currentBlock.addInstruction(OpCode2.CellNew, [{ kind: OperandKind2.Register, value: binding.register }], binding.register);
+        this.fnBuilder.addCapturedVariable(name);
+      }
+    }
+  }
+  lowerPendingParameterBindings() {
+    this.pendingParameterBindings.forEach(({ param, register }, index) => {
+      let valueReg = param.dotDotDotToken ? this.emitRestArgs(index) : this.loadFromLocal(register);
+      valueReg = this.applyDefaultValue(valueReg, param.initializer);
+      if (ts3.isIdentifier(param.name)) {
+        this.initializeDeclaredIdentifier(param.name.text, valueReg);
+        return;
+      }
+      this.bindPattern(param.name, valueReg, "declare");
+    });
+  }
+  loadOuterCaptureCell(name) {
+    const envIndex = this.outerCaptureBindings.get(name);
+    if (envIndex === void 0) {
+      this.failUnsupported(this.findIdentifierNode(name) ?? this.node, `Unknown closure binding "${name}"`);
+    }
+    const cellReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(OpCode2.EnvGet, [{ kind: OperandKind2.Immediate, value: envIndex }], cellReg);
+    return cellReg;
+  }
+  resolveVar(name) {
+    if (this.scope.has(name)) {
+      const binding = this.scope.get(name);
+      const destReg2 = this.fnBuilder.allocRegister();
+      if (binding.boxed) {
+        this.currentBlock.addInstruction(OpCode2.CellGet, [{ kind: OperandKind2.Register, value: binding.register }], destReg2);
+      } else {
+        this.currentBlock.addInstruction(OpCode2.LoadLocal, [{ kind: OperandKind2.Register, value: binding.register }], destReg2);
+      }
+      return destReg2;
+    }
+    if (this.outerCaptureBindings.has(name)) {
+      const cellReg = this.loadOuterCaptureCell(name);
+      const destReg2 = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(OpCode2.CellGet, [{ kind: OperandKind2.Register, value: cellReg }], destReg2);
+      return destReg2;
+    }
+    const strReg = this.emitConstant(ConstantKind2.String, name);
+    const destReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(OpCode2.LoadGlobal, [{ kind: OperandKind2.Register, value: strReg }], destReg);
+    return destReg;
+  }
+  findIdentifierNode(name) {
+    let match;
+    const visit = (node) => {
+      if (match) {
+        return;
+      }
+      if (ts3.isIdentifier(node) && node.text === name) {
+        match = node;
+        return;
+      }
+      ts3.forEachChild(node, visit);
+    };
+    if (this.node.body) {
+      ts3.forEachChild(this.node.body, visit);
+    }
+    return match;
+  }
+  createNestedFunctionName() {
+    const suffix = this.nestedFunctionCount++;
+    return `${this.fnBuilder.name}$closure$${suffix}`;
+  }
+  getAvailableOuterCaptureNames() {
+    const availableOuterNames = new Set(this.outerCaptureBindings.keys());
+    for (const name of this.scope.keys()) {
+      availableOuterNames.add(name);
+    }
+    if (this.canProvideLexicalThis()) {
+      availableOuterNames.add(LEXICAL_THIS_CAPTURE);
+    }
+    if (this.canProvideLexicalNewTarget()) {
+      availableOuterNames.add(LEXICAL_NEW_TARGET_CAPTURE);
+    }
+    return availableOuterNames;
+  }
+  canProvideLexicalThis() {
+    if (!ts3.isArrowFunction(this.node)) {
+      return true;
+    }
+    return this.scope.has(LEXICAL_THIS_CAPTURE) || this.outerCaptureBindings.has(LEXICAL_THIS_CAPTURE);
+  }
+  canProvideLexicalNewTarget() {
+    if (!ts3.isArrowFunction(this.node)) {
+      return true;
+    }
+    return this.scope.has(LEXICAL_NEW_TARGET_CAPTURE) || this.outerCaptureBindings.has(LEXICAL_NEW_TARGET_CAPTURE);
+  }
+  initializeLexicalSemanticCaptures(analysis) {
+    if (!ts3.isArrowFunction(this.node)) {
+      if (analysis.capturedByDescendants.has(LEXICAL_THIS_CAPTURE)) {
+        this.initializeLexicalCapture(LEXICAL_THIS_CAPTURE);
+      }
+      if (analysis.capturedByDescendants.has(LEXICAL_NEW_TARGET_CAPTURE)) {
+        this.initializeLexicalCapture(LEXICAL_NEW_TARGET_CAPTURE);
+      }
+      return;
+    }
+    if (analysis.capturedFromOuter.includes(LEXICAL_THIS_CAPTURE)) {
+      this.initializeLexicalCapture(LEXICAL_THIS_CAPTURE);
+    }
+    if (analysis.capturedFromOuter.includes(LEXICAL_NEW_TARGET_CAPTURE)) {
+      this.initializeLexicalCapture(LEXICAL_NEW_TARGET_CAPTURE);
+    }
+  }
+  initializeLexicalCapture(name) {
+    if (this.scope.has(name)) {
+      return;
+    }
+    const localReg = this.fnBuilder.addLocal(name, IRType.Any, true);
+    this.scope.set(name, { register: localReg, boxed: true });
+    let sourceValueReg;
+    if (this.outerCaptureBindings.has(name)) {
+      const outerCellReg = this.loadOuterCaptureCell(name);
+      sourceValueReg = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(OpCode2.CellGet, [{ kind: OperandKind2.Register, value: outerCellReg }], sourceValueReg);
+    } else if (name === LEXICAL_THIS_CAPTURE) {
+      sourceValueReg = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(OpCode2.LoadThis, [], sourceValueReg);
+    } else {
+      sourceValueReg = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(OpCode2.LoadNewTarget, [], sourceValueReg);
+    }
+    this.currentBlock.addInstruction(OpCode2.CellNew, [{ kind: OperandKind2.Register, value: sourceValueReg }], localReg);
+    this.fnBuilder.addCapturedVariable(name);
+  }
+  resolveLexicalCapture(name, node, detail) {
+    if (!this.scope.has(name) && !this.outerCaptureBindings.has(name)) {
+      this.failUnsupported(node, detail);
+    }
+    return this.resolveVar(name);
+  }
+  collectReferencedOuterNames(nodes, availableOuterNames) {
+    const referenced = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      if (ts3.isIdentifier(node) && availableOuterNames.has(node.text)) {
+        referenced.add(node.text);
+      }
+      ts3.forEachChild(node, visit);
+    };
+    nodes.forEach((node) => visit(node));
+    return [...referenced];
+  }
+  getFunctionAttributes(node) {
+    const attributes = [];
+    if (node.modifiers?.some((modifier) => modifier.kind === ts3.SyntaxKind.AsyncKeyword)) {
+      attributes.push(FunctionAttribute.Async);
+    }
+    if (ts3.isArrowFunction(node)) {
+      attributes.push(FunctionAttribute.Arrow);
+    }
+    if (ts3.isMethodDeclaration(node)) {
+      attributes.push(FunctionAttribute.Method);
+    }
+    if (ts3.isGetAccessorDeclaration(node)) {
+      attributes.push(FunctionAttribute.Getter);
+    }
+    if (ts3.isSetAccessorDeclaration(node)) {
+      attributes.push(FunctionAttribute.Setter);
+    }
+    if (ts3.isConstructorDeclaration(node)) {
+      attributes.push(FunctionAttribute.Constructor);
+    }
+    if ("asteriskToken" in node && !!node.asteriskToken) {
+      attributes.push(FunctionAttribute.Generator);
+    }
+    if (node.modifiers?.some((modifier) => modifier.kind === ts3.SyntaxKind.StaticKeyword)) {
+      attributes.push(FunctionAttribute.Static);
+    }
+    return attributes;
+  }
+  normalizeClassLike(node) {
+    let extendsExpression;
+    const extendsClause = node.heritageClauses?.find((clause) => clause.token === ts3.SyntaxKind.ExtendsKeyword);
+    if (extendsClause?.types && extendsClause.types.length > 0) {
+      extendsExpression = extendsClause.types[0]?.expression;
+    }
+    const computedNames = [];
+    const privateIdentifiers = /* @__PURE__ */ new Map();
+    const instanceElements = [];
+    const staticElements = [];
+    let constructorElement;
+    const pushElement = (element) => {
+      if (element.kind === "constructor") {
+        if (constructorElement) {
+          this.failUnsupported(element.node, "multiple constructors are not supported");
+        }
+        constructorElement = element;
+        instanceElements.push(element);
+        return;
+      }
+      if (element.isStatic) {
+        staticElements.push(element);
+      } else {
+        instanceElements.push(element);
+      }
+    };
+    for (const member of node.members) {
+      if (ts3.isSemicolonClassElement(member)) {
+        continue;
+      }
+      if (ts3.isClassStaticBlockDeclaration(member)) {
+        pushElement({
+          kind: "static_block",
+          node: member,
+          isStatic: true
+        });
+        continue;
+      }
+      const modifiers = ts3.canHaveModifiers(member) ? ts3.getModifiers(member) ?? [] : [];
+      if (ts3.isPropertyDeclaration(member) && modifiers.some((modifier) => modifier.kind === ts3.SyntaxKind.DeclareKeyword)) {
+        continue;
+      }
+      const privateBindingName = "name" in member && member.name && ts3.isPrivateIdentifier(member.name) ? privateIdentifiers.get(member.name.text) ?? this.createSyntheticBindingName("private_slot") : void 0;
+      if (privateBindingName && "name" in member && member.name && ts3.isPrivateIdentifier(member.name) && !privateIdentifiers.has(member.name.text)) {
+        privateIdentifiers.set(member.name.text, privateBindingName);
+      }
+      if (privateBindingName && !ts3.isPropertyDeclaration(member)) {
+        this.failUnsupported(member.name, "private class methods and accessors are not supported on the vm-safe path");
+      }
+      const isStatic = modifiers.some((modifier) => modifier.kind === ts3.SyntaxKind.StaticKeyword);
+      const computedBindingName = "name" in member && member.name && ts3.isComputedPropertyName(member.name) ? this.createSyntheticBindingName("class_key") : void 0;
+      if (computedBindingName && "name" in member && member.name && ts3.isComputedPropertyName(member.name)) {
+        computedNames.push({
+          bindingName: computedBindingName,
+          expression: member.name.expression
+        });
+      }
+      const keyName = "name" in member && member.name && !ts3.isComputedPropertyName(member.name) && !ts3.isPrivateIdentifier(member.name) ? this.getPropertyNameText(member.name) : void 0;
+      if (ts3.isConstructorDeclaration(member)) {
+        if (member.parameters.some((parameter) => parameter.modifiers?.length)) {
+          this.failUnsupported(member, "parameter properties are not supported on the vm-safe path");
+        }
+        pushElement({
+          kind: "constructor",
+          node: member,
+          isStatic: false
+        });
+        continue;
+      }
+      if (ts3.isMethodDeclaration(member)) {
+        pushElement({
+          kind: "method",
+          node: member,
+          isStatic,
+          keyName,
+          computedBindingName
+        });
+        continue;
+      }
+      if (ts3.isGetAccessorDeclaration(member)) {
+        pushElement({
+          kind: "getter",
+          node: member,
+          isStatic,
+          keyName,
+          computedBindingName
+        });
+        continue;
+      }
+      if (ts3.isSetAccessorDeclaration(member)) {
+        pushElement({
+          kind: "setter",
+          node: member,
+          isStatic,
+          keyName,
+          computedBindingName
+        });
+        continue;
+      }
+      if (ts3.isPropertyDeclaration(member)) {
+        pushElement({
+          kind: "field",
+          node: member,
+          isStatic,
+          keyName,
+          computedBindingName,
+          privateBindingName
+        });
+        continue;
+      }
+      this.failUnsupported(member, "unsupported class element");
+    }
+    return {
+      bindingName: node.name?.text,
+      constructorElement,
+      computedNames,
+      privateIdentifiers,
+      instanceElements,
+      staticElements,
+      extendsExpression
+    };
+  }
+  lowerClassConstructor(normalized, availableOuterNames, classDisplayName) {
+    const instanceFields = normalized.instanceElements.filter(
+      (element) => element.kind === "field"
+    );
+    const explicitCtor = normalized.constructorElement?.kind === "constructor" ? normalized.constructorElement.node : void 0;
+    let ctorNode;
+    if (explicitCtor) {
+      ctorNode = explicitCtor;
+    } else {
+      const bodyStatements = [];
+      if (normalized.extendsExpression) {
+        bodyStatements.push(ts3.factory.createExpressionStatement(ts3.factory.createCallExpression(ts3.factory.createSuper(), void 0, [])));
+      }
+      ctorNode = ts3.factory.createFunctionExpression(
+        void 0,
+        void 0,
+        void 0,
+        void 0,
+        [],
+        void 0,
+        ts3.factory.createBlock(bodyStatements, true)
+      );
+    }
+    const fieldInitializerNodes = instanceFields.flatMap((field) => {
+      const nodes = [];
+      if (field.node.initializer) {
+        nodes.push(field.node.initializer);
+      }
+      return nodes;
+    });
+    const computedFieldCaptureNames = instanceFields.map((field) => field.computedBindingName).filter((name) => !!name);
+    const extraCapturedFromOuter = [
+      ...this.collectReferencedOuterNames(fieldInitializerNodes, availableOuterNames),
+      ...computedFieldCaptureNames,
+      ...normalized.privateIdentifiers.values()
+    ];
+    const analysisBase = analyzeFunctionClosures(ctorNode, new Set(availableOuterNames));
+    const analysis = {
+      ...analysisBase,
+      capturedFromOuter: [.../* @__PURE__ */ new Set([...analysisBase.capturedFromOuter, ...extraCapturedFromOuter])]
+    };
+    const nestedName = this.createNestedFunctionName();
+    const nestedLowering = new _ASTLowering(this.modBuilder, ctorNode, {
+      name: nestedName,
+      isExported: false,
+      isVirtualized: true,
+      analysis,
+      attributes: [FunctionAttribute.Constructor],
+      isNested: true,
+      prologueEmitter: (lowering) => {
+        lowering.emitClassConstructorGuard(classDisplayName);
+        if (!normalized.extendsExpression) {
+          lowering.emitInstanceFieldInitializers(instanceFields);
+        }
+      },
+      privateIdentifierBindings: normalized.privateIdentifiers,
+      instanceFieldsToInitialize: normalized.extendsExpression ? instanceFields : void 0
+    });
+    const envReg = this.buildClosureEnvironment(analysis.capturedFromOuter);
+    const functionIdIndex = this.modBuilder.addConstant(ConstantKind2.String, nestedLowering.functionId);
+    const closureReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.ClosureNew,
+      [
+        { kind: OperandKind2.ConstantIndex, value: functionIdIndex },
+        { kind: OperandKind2.Register, value: envReg }
+      ],
+      closureReg
+    );
+    return closureReg;
+  }
+  lowerNestedFunctionLike(expr, explicitName, overrides) {
+    const nestedName = explicitName ?? this.createNestedFunctionName();
+    const availableOuterNames = overrides?.availableOuterNames ?? this.getAvailableOuterCaptureNames();
+    const baseAnalysis = analyzeFunctionClosures(expr, new Set(availableOuterNames));
+    const analysis = {
+      ...baseAnalysis,
+      capturedFromOuter: [.../* @__PURE__ */ new Set([...baseAnalysis.capturedFromOuter, ...overrides?.extraCapturedFromOuter ?? []])]
+    };
+    const nestedLowering = new _ASTLowering(this.modBuilder, expr, {
+      name: nestedName,
+      isExported: false,
+      isVirtualized: true,
+      analysis,
+      attributes: [...this.getFunctionAttributes(expr), ...overrides?.attributes ?? []],
+      isNested: true,
+      prologueEmitter: overrides?.prologueEmitter,
+      privateIdentifierBindings: overrides?.privateIdentifierBindings
+    });
+    const envReg = this.buildClosureEnvironment(analysis.capturedFromOuter);
+    const functionIdIndex = this.modBuilder.addConstant(ConstantKind2.String, nestedLowering.functionId);
+    const closureReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.ClosureNew,
+      [
+        { kind: OperandKind2.ConstantIndex, value: functionIdIndex },
+        { kind: OperandKind2.Register, value: envReg }
+      ],
+      closureReg
+    );
+    return closureReg;
+  }
+  emitClassMethodOrAccessorDescriptor(targetReg, keyReg, computed, element, fnReg) {
+    const descriptorReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(OpCode2.ObjectNew, [], descriptorReg);
+    const enumerableReg = this.emitConstant(ConstantKind2.Boolean, false);
+    const configurableReg = this.emitConstant(ConstantKind2.Boolean, true);
+    this.emitObjectPropertyWrite(descriptorReg, this.emitConstant(ConstantKind2.String, "enumerable"), enumerableReg, false);
+    this.emitObjectPropertyWrite(descriptorReg, this.emitConstant(ConstantKind2.String, "configurable"), configurableReg, false);
+    if (element.kind === "method" || element.kind === "constructor") {
+      const writableReg = this.emitConstant(ConstantKind2.Boolean, true);
+      this.emitObjectPropertyWrite(descriptorReg, this.emitConstant(ConstantKind2.String, "writable"), writableReg, false);
+      this.emitObjectPropertyWrite(descriptorReg, this.emitConstant(ConstantKind2.String, "value"), fnReg, false);
+      this.emitDefineProperty(targetReg, keyReg, descriptorReg);
+      return;
+    }
+    const existingDescriptorReg = this.buildAccessorDescriptorSource(targetReg, keyReg, computed);
+    const accessorValueReg = this.fnBuilder.allocRegister();
+    if (element.kind === "getter") {
+      this.emitObjectPropertyWrite(descriptorReg, this.emitConstant(ConstantKind2.String, "get"), fnReg, false);
+      this.currentBlock.addInstruction(
+        OpCode2.PropGet,
+        [
+          { kind: OperandKind2.Register, value: existingDescriptorReg },
+          { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "set") }
+        ],
+        accessorValueReg
+      );
+      this.emitObjectPropertyWrite(descriptorReg, this.emitConstant(ConstantKind2.String, "set"), accessorValueReg, false);
+    } else {
+      this.emitObjectPropertyWrite(descriptorReg, this.emitConstant(ConstantKind2.String, "set"), fnReg, false);
+      this.currentBlock.addInstruction(
+        OpCode2.PropGet,
+        [
+          { kind: OperandKind2.Register, value: existingDescriptorReg },
+          { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "get") }
+        ],
+        accessorValueReg
+      );
+      this.emitObjectPropertyWrite(descriptorReg, this.emitConstant(ConstantKind2.String, "get"), accessorValueReg, false);
+    }
+    this.emitDefineProperty(targetReg, keyReg, descriptorReg);
+  }
+  lowerClassLike(node, classBindingNameOverride) {
+    const extendsExpr = node.heritageClauses?.find((c) => c.token === ts3.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+    let parentClassReg;
+    if (extendsExpr) {
+      parentClassReg = this.visitExpression(extendsExpr);
+    }
+    const normalized = this.normalizeClassLike(node);
+    const classBindingName = classBindingNameOverride ?? normalized.bindingName;
+    let classBinding;
+    let restoreBinding;
+    if (classBindingName) {
+      if (classBindingNameOverride && classBindingNameOverride === normalized.bindingName) {
+        restoreBinding = this.scope.get(classBindingName);
+        classBinding = this.declareForcedBoxedIdentifier(classBindingName);
+      } else if (this.scope.has(classBindingName)) {
+        classBinding = this.scope.get(classBindingName);
+      } else {
+        classBinding = this.declareForcedBoxedIdentifier(classBindingName);
+      }
+    }
+    for (const computedName of normalized.computedNames) {
+      this.declareForcedBoxedIdentifier(computedName.bindingName);
+      const valueReg = this.visitExpression(computedName.expression);
+      this.initializeDeclaredIdentifier(computedName.bindingName, valueReg);
+    }
+    for (const bindingName of normalized.privateIdentifiers.values()) {
+      this.declareForcedBoxedIdentifier(bindingName);
+      this.initializeDeclaredIdentifier(bindingName, this.emitConstant(ConstantKind2.String, bindingName));
+    }
+    const availableOuterNames = this.getAvailableOuterCaptureNames();
+    const ctorReg = this.lowerClassConstructor(normalized, availableOuterNames, classBindingName ?? "<anonymous>");
+    if (classBindingName) {
+      this.initializeDeclaredIdentifier(classBindingName, ctorReg);
+    }
+    const prototypeReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.PropGet,
+      [
+        { kind: OperandKind2.Register, value: ctorReg },
+        { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "prototype") }
+      ],
+      prototypeReg
+    );
+    if (parentClassReg) {
+      const parentProtoReg = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(
+        OpCode2.PropGet,
+        [
+          { kind: OperandKind2.Register, value: parentClassReg },
+          { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "prototype") }
+        ],
+        parentProtoReg
+      );
+      const setPrototypeOfReg = this.resolveVar("Object");
+      const setProtoMethodReg = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(
+        OpCode2.PropGet,
+        [
+          { kind: OperandKind2.Register, value: setPrototypeOfReg },
+          { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "setPrototypeOf") }
+        ],
+        setProtoMethodReg
+      );
+      this.currentBlock.addInstruction(
+        OpCode2.Call,
+        [
+          { kind: OperandKind2.Register, value: setProtoMethodReg },
+          { kind: OperandKind2.Register, value: prototypeReg },
+          { kind: OperandKind2.Register, value: parentProtoReg }
+        ],
+        this.fnBuilder.allocRegister()
+      );
+      this.currentBlock.addInstruction(
+        OpCode2.Call,
+        [
+          { kind: OperandKind2.Register, value: setProtoMethodReg },
+          { kind: OperandKind2.Register, value: ctorReg },
+          { kind: OperandKind2.Register, value: parentClassReg }
+        ],
+        this.fnBuilder.allocRegister()
+      );
+    }
+    for (const element of normalized.instanceElements) {
+      if (element.kind === "field" || element.kind === "constructor") {
+        continue;
+      }
+      const methodElement = element;
+      const methodReg = this.lowerNestedFunctionLike(methodElement.node, void 0, {
+        availableOuterNames,
+        extraCapturedFromOuter: [...normalized.privateIdentifiers.values()],
+        privateIdentifierBindings: normalized.privateIdentifiers
+      });
+      const key = this.getPropertyKeyRegister(methodElement.keyName, methodElement.computedBindingName);
+      this.emitClassMethodOrAccessorDescriptor(prototypeReg, key.register, key.computed, methodElement, methodReg);
+    }
+    for (const element of normalized.staticElements) {
+      if (element.kind === "field") {
+        const valueReg = element.node.initializer ? this.visitExpression(element.node.initializer) : this.emitConstant(ConstantKind2.Undefined, null);
+        if (element.privateBindingName) {
+          const privateKeyReg = this.resolveVar(element.privateBindingName);
+          this.currentBlock.addInstruction(OpCode2.PrivateSet, [
+            { kind: OperandKind2.Register, value: ctorReg },
+            { kind: OperandKind2.Register, value: privateKeyReg },
+            { kind: OperandKind2.Register, value: valueReg }
+          ]);
+          continue;
+        }
+        const key2 = this.getPropertyKeyRegister(element.keyName, element.computedBindingName);
+        this.emitObjectPropertyWrite(ctorReg, key2.register, valueReg, key2.computed);
+        continue;
+      }
+      if (element.kind === "static_block") {
+        const fakeFn = ts3.factory.createFunctionExpression(void 0, void 0, void 0, void 0, [], void 0, element.node.body);
+        const fnReg = this.lowerNestedFunctionLike(fakeFn, void 0, {
+          availableOuterNames,
+          extraCapturedFromOuter: [...normalized.privateIdentifiers.values()],
+          privateIdentifierBindings: normalized.privateIdentifiers,
+          attributes: [FunctionAttribute.Static]
+        });
+        const callPropReg = this.emitConstant(ConstantKind2.String, "call");
+        this.currentBlock.addInstruction(
+          OpCode2.CallMethod,
+          [
+            { kind: OperandKind2.Register, value: fnReg },
+            { kind: OperandKind2.Register, value: callPropReg },
+            { kind: OperandKind2.Register, value: ctorReg }
+          ],
+          this.fnBuilder.allocRegister()
+        );
+        continue;
+      }
+      const methodElement = element;
+      const methodReg = this.lowerNestedFunctionLike(methodElement.node, void 0, {
+        availableOuterNames,
+        extraCapturedFromOuter: [...normalized.privateIdentifiers.values()],
+        privateIdentifierBindings: normalized.privateIdentifiers
+      });
+      const key = this.getPropertyKeyRegister(methodElement.keyName, methodElement.computedBindingName);
+      this.emitClassMethodOrAccessorDescriptor(ctorReg, key.register, key.computed, methodElement, methodReg);
+    }
+    if (restoreBinding) {
+      this.scope.set(classBindingName, restoreBinding);
+    } else if (classBindingNameOverride && classBindingNameOverride === normalized.bindingName) {
+      this.scope.delete(classBindingName);
+    }
+    return ctorReg;
+  }
+  emitClassConstructorGuard(classDisplayName) {
+    const newTargetReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(OpCode2.LoadNewTarget, [], newTargetReg);
+    const undefinedReg = this.emitConstant(ConstantKind2.Undefined, null);
+    const isUndefinedReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.StrictEq,
+      [
+        { kind: OperandKind2.Register, value: newTargetReg },
+        { kind: OperandKind2.Register, value: undefinedReg }
+      ],
+      isUndefinedReg
+    );
+    const throwBlock = this.fnBuilder.createBlock("class_ctor_throw");
+    const continueBlock = this.fnBuilder.createBlock("class_ctor_continue");
+    this.currentBlock.setTerminator({ kind: "branch", condition: isUndefinedReg, targets: [throwBlock.id, continueBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = throwBlock;
+    const typeErrorReg = this.resolveVar("TypeError");
+    const messageReg = this.emitConstant(ConstantKind2.String, `Class constructor ${classDisplayName} cannot be invoked without 'new'`);
+    const errorReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.New,
+      [
+        { kind: OperandKind2.Register, value: typeErrorReg },
+        { kind: OperandKind2.Register, value: messageReg }
+      ],
+      errorReg
+    );
+    this.currentBlock.setTerminator({ kind: "throw", targets: [], returnValue: errorReg });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = continueBlock;
+  }
+  emitInstanceFieldInitializers(fields) {
+    if (fields.length === 0) {
+      return;
+    }
+    const thisReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(OpCode2.LoadThis, [], thisReg);
+    for (const field of fields) {
+      const valueReg = field.node.initializer ? this.visitExpression(field.node.initializer) : this.emitConstant(ConstantKind2.Undefined, null);
+      if (field.privateBindingName) {
+        const privateKeyReg = this.resolveVar(field.privateBindingName);
+        this.currentBlock.addInstruction(OpCode2.PrivateSet, [
+          { kind: OperandKind2.Register, value: thisReg },
+          { kind: OperandKind2.Register, value: privateKeyReg },
+          { kind: OperandKind2.Register, value: valueReg }
+        ]);
+        continue;
+      }
+      const key = this.getPropertyKeyRegister(field.keyName, field.computedBindingName);
+      this.emitObjectPropertyWrite(thisReg, key.register, valueReg, key.computed);
+    }
+  }
+  resolvePrivateIdentifierRegister(identifier) {
+    const bindingName = this.privateIdentifierBindings.get(identifier.text);
+    if (!bindingName) {
+      this.failUnsupported(identifier, `Unknown private identifier ${identifier.text}`);
+    }
+    return this.resolveVar(bindingName);
+  }
+  lowerNestedFunction(expr) {
+    return this.lowerNestedFunctionLike(expr);
+  }
+  buildClosureEnvironment(capturedNames) {
+    const envReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(OpCode2.ArrayNew, [], envReg);
+    capturedNames.forEach((name, index) => {
+      const indexReg = this.emitConstant(ConstantKind2.Number, index);
+      const cellReg = this.getCellForCapture(name);
+      this.currentBlock.addInstruction(OpCode2.ComputedSet, [
+        { kind: OperandKind2.Register, value: envReg },
+        { kind: OperandKind2.Register, value: indexReg },
+        { kind: OperandKind2.Register, value: cellReg }
+      ]);
+    });
+    return envReg;
+  }
+  getCellForCapture(name) {
+    const localBinding = this.scope.get(name);
+    if (localBinding) {
+      if (!localBinding.boxed) {
+        this.currentBlock.addInstruction(
+          OpCode2.CellNew,
+          [{ kind: OperandKind2.Register, value: localBinding.register }],
+          localBinding.register
+        );
+        this.scope.set(name, { register: localBinding.register, boxed: true });
+        this.fnBuilder.addCapturedVariable(name);
+        return localBinding.register;
+      }
+      return localBinding.register;
+    }
+    if (name === LEXICAL_THIS_CAPTURE || name === LEXICAL_NEW_TARGET_CAPTURE) {
+      this.initializeLexicalCapture(name);
+      const lexicalBinding = this.scope.get(name);
+      if (lexicalBinding?.boxed) {
+        return lexicalBinding.register;
+      }
+    }
+    if (this.outerCaptureBindings.has(name)) {
+      return this.loadOuterCaptureCell(name);
+    }
+    this.failUnsupported(this.findIdentifierNode(name) ?? this.node, `Unknown capture "${name}"`);
+  }
+  storeValue(target, valueReg) {
+    target = this.normalizeExpression(target);
+    if (ts3.isIdentifier(target)) {
+      if (this.scope.has(target.text)) {
+        const binding = this.scope.get(target.text);
+        if (binding.boxed) {
+          this.currentBlock.addInstruction(OpCode2.CellSet, [
+            { kind: OperandKind2.Register, value: binding.register },
+            { kind: OperandKind2.Register, value: valueReg }
+          ]);
+        } else {
+          this.currentBlock.addInstruction(OpCode2.StoreLocal, [
+            { kind: OperandKind2.Register, value: binding.register },
+            { kind: OperandKind2.Register, value: valueReg }
+          ]);
+        }
+      } else if (this.outerCaptureBindings.has(target.text)) {
+        const cellReg = this.loadOuterCaptureCell(target.text);
+        this.currentBlock.addInstruction(OpCode2.CellSet, [
+          { kind: OperandKind2.Register, value: cellReg },
+          { kind: OperandKind2.Register, value: valueReg }
+        ]);
+      } else {
+        const strReg = this.emitConstant(ConstantKind2.String, target.text);
+        this.currentBlock.addInstruction(OpCode2.StoreGlobal, [
+          { kind: OperandKind2.Register, value: strReg },
+          { kind: OperandKind2.Register, value: valueReg }
+        ]);
+      }
+      return;
+    }
+    if (ts3.isPropertyAccessExpression(target)) {
+      if (target.expression.kind === ts3.SyntaxKind.SuperKeyword) {
+        const propReg2 = this.emitConstant(ConstantKind2.String, target.name.text);
+        this.currentBlock.addInstruction(OpCode2.SuperPropSet, [
+          { kind: OperandKind2.Register, value: propReg2 },
+          { kind: OperandKind2.Register, value: valueReg }
+        ]);
+        return;
+      }
+      const objReg = this.visitExpression(target.expression);
+      const propReg = this.emitConstant(ConstantKind2.String, target.name.text);
+      if (ts3.isPrivateIdentifier(target.name)) {
+        const privateKeyReg = this.resolvePrivateIdentifierRegister(target.name);
+        this.currentBlock.addInstruction(OpCode2.PrivateSet, [
+          { kind: OperandKind2.Register, value: objReg },
+          { kind: OperandKind2.Register, value: privateKeyReg },
+          { kind: OperandKind2.Register, value: valueReg }
+        ]);
+        return;
+      }
+      this.currentBlock.addInstruction(OpCode2.PropSet, [
+        { kind: OperandKind2.Register, value: objReg },
+        { kind: OperandKind2.Register, value: propReg },
+        { kind: OperandKind2.Register, value: valueReg }
+      ]);
+      return;
+    }
+    if (ts3.isElementAccessExpression(target)) {
+      if (!target.argumentExpression) {
+        this.failUnsupported(target, "Element access assignment requires an index expression");
+      }
+      const objReg = this.visitExpression(target.expression);
+      const indexReg = this.visitExpression(target.argumentExpression);
+      this.currentBlock.addInstruction(OpCode2.ComputedSet, [
+        { kind: OperandKind2.Register, value: objReg },
+        { kind: OperandKind2.Register, value: indexReg },
+        { kind: OperandKind2.Register, value: valueReg }
+      ]);
+      return;
+    }
+    if (ts3.isArrayLiteralExpression(target)) {
+      this.storeArrayPattern(target, valueReg);
+      return;
+    }
+    if (ts3.isObjectLiteralExpression(target)) {
+      this.storeObjectPattern(target, valueReg);
+      return;
+    }
+    this.failUnsupported(target, "Unsupported assignment target");
+  }
+  readValue(target) {
+    if (ts3.isIdentifier(target)) {
+      return this.resolveVar(target.text);
+    }
+    if (ts3.isPropertyAccessExpression(target) || ts3.isElementAccessExpression(target)) {
+      return this.visitExpression(target);
+    }
+    this.failUnsupported(target, "Unsupported read target");
+  }
+  emitObjectPropertyAssignment(objectReg, nameReg, valueReg, computed = false) {
+    this.currentBlock.addInstruction(computed ? OpCode2.ComputedSet : OpCode2.PropSet, [
+      { kind: OperandKind2.Register, value: objectReg },
+      { kind: OperandKind2.Register, value: nameReg },
+      { kind: OperandKind2.Register, value: valueReg }
+    ]);
+  }
+  normalizeExpression(expr) {
+    let current = expr;
+    while (ts3.isParenthesizedExpression(current) || ts3.isAsExpression(current) || ts3.isNonNullExpression(current) || ts3.isSatisfiesExpression(current) || ts3.isTypeAssertionExpression(current)) {
+      if (ts3.isParenthesizedExpression(current)) {
+        current = current.expression;
+      } else {
+        current = current.expression;
+      }
+    }
+    return current;
+  }
+  createTempLocal(prefix) {
+    return this.fnBuilder.addLocal(`$${prefix}_${this.tempLocalCount++}`, IRType.Any);
+  }
+  createSyntheticBindingName(prefix) {
+    return `$$${prefix}_${this.tempLocalCount++}`;
+  }
+  declareScopedIdentifier(name) {
+    if (this.scope.hasOwn(name)) {
+      return this.scope.get(name);
+    }
+    const boxed = this.capturedLocals.has(name);
+    const register = this.fnBuilder.addLocal(name, IRType.Any);
+    const binding = { register, boxed };
+    this.scope.set(name, binding);
+    return binding;
+  }
+  declareForcedBoxedIdentifier(name) {
+    const existing = this.scope.get(name);
+    if (existing) {
+      return existing;
+    }
+    const register = this.fnBuilder.addLocal(name, IRType.Any, true);
+    const binding = { register, boxed: true };
+    this.scope.set(name, binding);
+    const undefReg = this.emitConstant(ConstantKind2.Undefined, null);
+    this.currentBlock.addInstruction(OpCode2.CellNew, [{ kind: OperandKind2.Register, value: undefReg }], binding.register);
+    this.fnBuilder.addCapturedVariable(name);
+    return binding;
+  }
+  withTemporaryBinding(name, callback) {
+    const restoreBinding = this.scope.get(name);
+    const binding = this.declareForcedBoxedIdentifier(name);
+    const result = callback();
+    if (restoreBinding) {
+      this.scope.set(name, restoreBinding);
+    } else {
+      this.scope.delete(name);
+    }
+    return { result, binding, restoreBinding };
+  }
+  getPropertyKeyRegister(keyName, computedBindingName) {
+    if (computedBindingName) {
+      return {
+        register: this.resolveVar(computedBindingName),
+        computed: true
+      };
+    }
+    if (keyName === void 0) {
+      this.failUnsupported(this.node, "Missing class element key");
+    }
+    return {
+      register: this.emitConstant(ConstantKind2.String, keyName),
+      computed: false
+    };
+  }
+  buildAccessorDescriptorSource(targetReg, keyReg, computed) {
+    const descriptorReg = this.fnBuilder.allocRegister();
+    const objectReg = this.resolveVar("Object");
+    const descriptorMethod = this.emitConstant(ConstantKind2.String, "getOwnPropertyDescriptor");
+    const callArgs = [
+      { kind: OperandKind2.Register, value: objectReg },
+      { kind: OperandKind2.Register, value: descriptorMethod },
+      { kind: OperandKind2.Register, value: targetReg },
+      { kind: OperandKind2.Register, value: keyReg }
+    ];
+    this.currentBlock.addInstruction(OpCode2.CallMethod, callArgs, descriptorReg);
+    const descriptorLocal = this.createTempLocal("accessor_desc");
+    this.storeToLocal(descriptorLocal, descriptorReg);
+    const undefinedReg = this.emitConstant(ConstantKind2.Undefined, null);
+    const isUndefinedReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.StrictEq,
+      [
+        { kind: OperandKind2.Register, value: descriptorReg },
+        { kind: OperandKind2.Register, value: undefinedReg }
+      ],
+      isUndefinedReg
+    );
+    const undefinedBlock = this.fnBuilder.createBlock("accessor_desc_undefined");
+    const endBlock = this.fnBuilder.createBlock("accessor_desc_end");
+    this.currentBlock.setTerminator({ kind: "branch", condition: isUndefinedReg, targets: [undefinedBlock.id, endBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = undefinedBlock;
+    const emptyDescriptorReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(OpCode2.ObjectNew, [], emptyDescriptorReg);
+    this.storeToLocal(descriptorLocal, emptyDescriptorReg);
+    this.currentBlock.setTerminator({ kind: "jump", targets: [endBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = endBlock;
+    return this.loadFromLocal(descriptorLocal);
+  }
+  emitObjectPropertyWrite(targetReg, keyReg, valueReg, computed) {
+    this.currentBlock.addInstruction(computed ? OpCode2.ComputedSet : OpCode2.PropSet, [
+      { kind: OperandKind2.Register, value: targetReg },
+      { kind: OperandKind2.Register, value: keyReg },
+      { kind: OperandKind2.Register, value: valueReg }
+    ]);
+  }
+  emitDefineProperty(targetReg, keyReg, descriptorReg) {
+    const objectReg = this.resolveVar("Object");
+    const definePropertyReg = this.emitConstant(ConstantKind2.String, "defineProperty");
+    this.currentBlock.addInstruction(
+      OpCode2.CallMethod,
+      [
+        { kind: OperandKind2.Register, value: objectReg },
+        { kind: OperandKind2.Register, value: definePropertyReg },
+        { kind: OperandKind2.Register, value: targetReg },
+        { kind: OperandKind2.Register, value: keyReg },
+        { kind: OperandKind2.Register, value: descriptorReg }
+      ],
+      this.fnBuilder.allocRegister()
+    );
+  }
+  initializeDeclaredIdentifier(name, initializerReg) {
+    const existing = this.scope.get(name);
+    const binding = this.declareScopedIdentifier(name);
+    if (initializerReg !== void 0) {
+      if (binding.boxed) {
+        if (existing) {
+          this.currentBlock.addInstruction(OpCode2.CellSet, [
+            { kind: OperandKind2.Register, value: binding.register },
+            { kind: OperandKind2.Register, value: initializerReg }
+          ]);
+        } else {
+          this.currentBlock.addInstruction(OpCode2.CellNew, [{ kind: OperandKind2.Register, value: initializerReg }], binding.register);
+          this.fnBuilder.addCapturedVariable(name);
+        }
+      } else {
+        this.currentBlock.addInstruction(OpCode2.StoreLocal, [
+          { kind: OperandKind2.Register, value: binding.register },
+          { kind: OperandKind2.Register, value: initializerReg }
+        ]);
+      }
+      return;
+    }
+    if (binding.boxed) {
+      const undefReg = this.emitConstant(ConstantKind2.Undefined, null);
+      this.currentBlock.addInstruction(OpCode2.CellNew, [{ kind: OperandKind2.Register, value: undefReg }], binding.register);
+      this.fnBuilder.addCapturedVariable(name);
+    }
+  }
+  applyDefaultValue(sourceReg, initializer) {
+    if (!initializer) {
+      return sourceReg;
+    }
+    const undefinedReg = this.emitConstant(ConstantKind2.Undefined, null);
+    const isUndefinedReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.StrictEq,
+      [
+        { kind: OperandKind2.Register, value: sourceReg },
+        { kind: OperandKind2.Register, value: undefinedReg }
+      ],
+      isUndefinedReg
+    );
+    return this.lowerConditionalExpression(
+      isUndefinedReg,
+      () => this.visitExpression(initializer),
+      () => sourceReg
+    );
+  }
+  materializeBindingElementValue(element, sourceReg) {
+    return this.applyDefaultValue(sourceReg, element.initializer);
+  }
+  emitRestArgs(startIndex) {
+    const destReg = this.fnBuilder.allocRegister();
+    const indexReg = this.emitConstant(ConstantKind2.Number, startIndex);
+    this.currentBlock.addInstruction(OpCode2.RestArgs, [{ kind: OperandKind2.Register, value: indexReg }], destReg);
+    return destReg;
+  }
+  emitArraySlice(sourceReg, startIndex) {
+    const destReg = this.fnBuilder.allocRegister();
+    const indexReg = this.emitConstant(ConstantKind2.Number, startIndex);
+    this.currentBlock.addInstruction(
+      OpCode2.CallMethod,
+      [
+        { kind: OperandKind2.Register, value: sourceReg },
+        { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "slice") },
+        { kind: OperandKind2.Register, value: indexReg }
+      ],
+      destReg
+    );
+    return destReg;
+  }
+  emitSpreadInto(targetReg, sourceReg) {
+    this.currentBlock.addInstruction(OpCode2.Spread, [
+      { kind: OperandKind2.Register, value: targetReg },
+      { kind: OperandKind2.Register, value: sourceReg }
+    ]);
+  }
+  emitSpreadIntoArray(targetReg, sourceReg, startIndexReg, destIndexLocal) {
+    const spreadCountReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.SpreadIntoArray,
+      [
+        { kind: OperandKind2.Register, value: targetReg },
+        { kind: OperandKind2.Register, value: sourceReg },
+        { kind: OperandKind2.Register, value: startIndexReg }
+      ],
+      spreadCountReg
+    );
+    const nextIndexReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.Add,
+      [
+        { kind: OperandKind2.Register, value: startIndexReg },
+        { kind: OperandKind2.Register, value: spreadCountReg }
+      ],
+      nextIndexReg
+    );
+    this.storeToLocal(destIndexLocal, nextIndexReg);
+  }
+  bindPattern(bindingName, sourceReg, mode = "declare") {
+    if (ts3.isIdentifier(bindingName)) {
+      if (mode === "declare") {
+        this.initializeDeclaredIdentifier(bindingName.text, sourceReg);
+      } else {
+        this.storeValue(bindingName, sourceReg);
+      }
+      return;
+    }
+    if (ts3.isObjectBindingPattern(bindingName)) {
+      let restElement;
+      const excludedKeys = [];
+      for (const element of bindingName.elements) {
+        if (element.dotDotDotToken) {
+          restElement = element;
+          continue;
+        }
+        const propertyName = element.propertyName ?? element.name;
+        if (ts3.isObjectBindingPattern(propertyName) || ts3.isArrayBindingPattern(propertyName)) {
+          this.failUnsupported(propertyName, "Invalid binding property name pattern");
+        }
+        const keyReg = ts3.isComputedPropertyName(propertyName) ? this.visitExpression(propertyName.expression) : this.emitConstant(ConstantKind2.String, this.getPropertyNameText(propertyName));
+        excludedKeys.push(keyReg);
+        const valueReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.PropGet,
+          [
+            { kind: OperandKind2.Register, value: sourceReg },
+            { kind: OperandKind2.Register, value: keyReg }
+          ],
+          valueReg
+        );
+        this.bindPattern(element.name, this.materializeBindingElementValue(element, valueReg), mode);
+      }
+      if (restElement) {
+        const restReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(OpCode2.ObjectNew, [], restReg);
+        this.emitSpreadInto(restReg, sourceReg);
+        excludedKeys.forEach((keyReg) => {
+          this.currentBlock.addInstruction(OpCode2.Delete, [
+            { kind: OperandKind2.Register, value: restReg },
+            { kind: OperandKind2.Register, value: keyReg }
+          ]);
+        });
+        this.bindPattern(restElement.name, restReg, mode);
+      }
+      return;
+    }
+    if (ts3.isArrayBindingPattern(bindingName)) {
+      bindingName.elements.forEach((element, index) => {
+        if (ts3.isOmittedExpression(element)) {
+          return;
+        }
+        if (element.dotDotDotToken) {
+          this.bindPattern(element.name, this.emitArraySlice(sourceReg, index), mode);
+          return;
+        }
+        const indexReg = this.emitConstant(ConstantKind2.Number, index);
+        const valueReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.ComputedGet,
+          [
+            { kind: OperandKind2.Register, value: sourceReg },
+            { kind: OperandKind2.Register, value: indexReg }
+          ],
+          valueReg
+        );
+        this.bindPattern(element.name, this.materializeBindingElementValue(element, valueReg), mode);
+      });
+      return;
+    }
+    this.failUnsupported(bindingName, "Unsupported binding pattern");
+  }
+  initializeVariableDeclaration(decl) {
+    const initializerReg = decl.initializer ? this.visitExpression(decl.initializer) : void 0;
+    if (ts3.isIdentifier(decl.name)) {
+      this.initializeDeclaredIdentifier(decl.name.text, initializerReg);
+      return;
+    }
+    if (initializerReg === void 0) {
+      this.failUnsupported(decl.name, "Destructuring declarations require an initializer");
+    }
+    this.bindPattern(decl.name, initializerReg, "declare");
+  }
+  assignLoopBinding(initializer, valueReg, loopKind) {
+    if (ts3.isVariableDeclarationList(initializer)) {
+      if (initializer.declarations.length !== 1) {
+        this.failUnsupported(initializer, `${loopKind} supports a single declaration only`);
+      }
+      const decl = initializer.declarations[0];
+      if (decl.initializer) {
+        this.failUnsupported(decl, `${loopKind} declaration initializers are not supported`);
+      }
+      if (ts3.isIdentifier(decl.name)) {
+        this.initializeDeclaredIdentifier(decl.name.text, valueReg);
+        return;
+      }
+      this.bindPattern(decl.name, valueReg, "declare");
+      return;
+    }
+    this.storeValue(initializer, valueReg);
+  }
+  loadFromLocal(localReg) {
+    const destReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(OpCode2.LoadLocal, [{ kind: OperandKind2.Register, value: localReg }], destReg);
+    return destReg;
+  }
+  getActiveFinallyContext() {
+    return this.finallyContexts[this.finallyContexts.length - 1];
+  }
+  withFinallyContext(context, callback) {
+    this.finallyContexts.push(context);
+    try {
+      return callback();
+    } finally {
+      this.finallyContexts.pop();
+    }
+  }
+  withPassthroughThrow(callback) {
+    this.throwPassthroughFinallyDepth += 1;
+    try {
+      return callback();
+    } finally {
+      this.throwPassthroughFinallyDepth -= 1;
+    }
+  }
+  createFinallyContext(finallyBlockId) {
+    return {
+      finallyBlockId,
+      completionKindLocal: this.createTempLocal("completion_kind"),
+      completionValueLocal: this.createTempLocal("completion_value"),
+      completionTargetLocal: this.createTempLocal("completion_target"),
+      targets: []
+    };
+  }
+  getCompletionTargetCode(context, kind, blockId) {
+    const existing = context.targets.find((target) => target.kind === kind && target.blockId === blockId);
+    if (existing) {
+      return existing.code;
+    }
+    const code = context.targets.length + 1;
+    context.targets.push({ code, kind, blockId });
+    return code;
+  }
+  setFinallyCompletion(context, kind, valueReg, target) {
+    this.storeToLocal(context.completionKindLocal, this.emitConstant(ConstantKind2.Number, kind));
+    if (valueReg) {
+      this.storeToLocal(context.completionValueLocal, valueReg);
+    }
+    if (target) {
+      const codeReg = this.emitConstant(ConstantKind2.Number, this.getCompletionTargetCode(context, target.kind, target.blockId));
+      this.storeToLocal(context.completionTargetLocal, codeReg);
+    }
+  }
+  routeAbruptCompletionThroughFinally(kind, valueReg, target) {
+    if (kind === 2 && this.throwPassthroughFinallyDepth > 0) {
+      this.currentBlock.setTerminator({ kind: "throw", targets: [], returnValue: valueReg });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+      this.currentBlock = this.fnBuilder.createBlock("unreachable");
+      return;
+    }
+    const context = this.getActiveFinallyContext();
+    if (!context) {
+      if (kind === 1) {
+        this.currentBlock.setTerminator({ kind: "return", targets: [], returnValue: valueReg });
+      } else if (kind === 2) {
+        this.currentBlock.setTerminator({ kind: "throw", targets: [], returnValue: valueReg });
+      } else if ((kind === 3 || kind === 4) && target) {
+        this.currentBlock.setTerminator({ kind: "jump", targets: [target.blockId] });
+      }
+      this.fnBuilder.addBlock(this.currentBlock.build());
+      this.currentBlock = this.fnBuilder.createBlock("unreachable");
+      return;
+    }
+    this.setFinallyCompletion(context, kind, valueReg, target);
+    this.emitJumpAndAdvance(context.finallyBlockId, "unreachable");
+  }
+  emitCompletionTargetDispatch(context, kind, fallbackTargetId) {
+    const targets = context.targets.filter((target) => target.kind === kind);
+    if (targets.length === 0) {
+      this.currentBlock.setTerminator({ kind: "jump", targets: [fallbackTargetId] });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+      return;
+    }
+    targets.forEach((target, index) => {
+      const targetCodeReg = this.loadFromLocal(context.completionTargetLocal);
+      const expectedCodeReg = this.emitConstant(ConstantKind2.Number, target.code);
+      const isMatchReg = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(
+        OpCode2.StrictEq,
+        [
+          { kind: OperandKind2.Register, value: targetCodeReg },
+          { kind: OperandKind2.Register, value: expectedCodeReg }
+        ],
+        isMatchReg
+      );
+      const fallbackBlock = index === targets.length - 1 ? void 0 : this.fnBuilder.createBlock(`finally_${kind}_dispatch_${index}`);
+      this.currentBlock.setTerminator({
+        kind: "branch",
+        condition: isMatchReg,
+        targets: [target.blockId, fallbackBlock?.id ?? fallbackTargetId]
+      });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+      if (fallbackBlock) {
+        this.currentBlock = fallbackBlock;
+      }
+    });
+  }
+  emitCompletionDispatch(context, normalTargetId) {
+    const normalCheckBlock = this.fnBuilder.createBlock("finally_normal_check");
+    this.currentBlock.setTerminator({ kind: "jump", targets: [normalCheckBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = normalCheckBlock;
+    const normalKindReg = this.loadFromLocal(context.completionKindLocal);
+    const normalConstReg = this.emitConstant(ConstantKind2.Number, 0);
+    const isNormalReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.StrictEq,
+      [
+        { kind: OperandKind2.Register, value: normalKindReg },
+        { kind: OperandKind2.Register, value: normalConstReg }
+      ],
+      isNormalReg
+    );
+    const returnCheckBlock = this.fnBuilder.createBlock("finally_return_check");
+    this.currentBlock.setTerminator({ kind: "branch", condition: isNormalReg, targets: [normalTargetId, returnCheckBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = returnCheckBlock;
+    const returnKindReg = this.loadFromLocal(context.completionKindLocal);
+    const returnConstReg = this.emitConstant(ConstantKind2.Number, 1);
+    const isReturnReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.StrictEq,
+      [
+        { kind: OperandKind2.Register, value: returnKindReg },
+        { kind: OperandKind2.Register, value: returnConstReg }
+      ],
+      isReturnReg
+    );
+    const returnBlock = this.fnBuilder.createBlock("finally_return");
+    const throwCheckBlock = this.fnBuilder.createBlock("finally_throw_check");
+    this.currentBlock.setTerminator({ kind: "branch", condition: isReturnReg, targets: [returnBlock.id, throwCheckBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = returnBlock;
+    this.currentBlock.setTerminator({ kind: "return", targets: [], returnValue: this.loadFromLocal(context.completionValueLocal) });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = throwCheckBlock;
+    const throwKindReg = this.loadFromLocal(context.completionKindLocal);
+    const throwConstReg = this.emitConstant(ConstantKind2.Number, 2);
+    const isThrowReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.StrictEq,
+      [
+        { kind: OperandKind2.Register, value: throwKindReg },
+        { kind: OperandKind2.Register, value: throwConstReg }
+      ],
+      isThrowReg
+    );
+    const throwBlock = this.fnBuilder.createBlock("finally_throw");
+    const breakCheckBlock = this.fnBuilder.createBlock("finally_break_check");
+    this.currentBlock.setTerminator({ kind: "branch", condition: isThrowReg, targets: [throwBlock.id, breakCheckBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = throwBlock;
+    this.currentBlock.setTerminator({ kind: "throw", targets: [], returnValue: this.loadFromLocal(context.completionValueLocal) });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = breakCheckBlock;
+    const breakKindReg = this.loadFromLocal(context.completionKindLocal);
+    const breakConstReg = this.emitConstant(ConstantKind2.Number, 3);
+    const isBreakReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.StrictEq,
+      [
+        { kind: OperandKind2.Register, value: breakKindReg },
+        { kind: OperandKind2.Register, value: breakConstReg }
+      ],
+      isBreakReg
+    );
+    const breakDispatchBlock = this.fnBuilder.createBlock("finally_break_dispatch");
+    const continueCheckBlock = this.fnBuilder.createBlock("finally_continue_check");
+    this.currentBlock.setTerminator({ kind: "branch", condition: isBreakReg, targets: [breakDispatchBlock.id, continueCheckBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = breakDispatchBlock;
+    this.emitCompletionTargetDispatch(context, "break", normalTargetId);
+    this.currentBlock = continueCheckBlock;
+    const continueKindReg = this.loadFromLocal(context.completionKindLocal);
+    const continueConstReg = this.emitConstant(ConstantKind2.Number, 4);
+    const isContinueReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(
+      OpCode2.StrictEq,
+      [
+        { kind: OperandKind2.Register, value: continueKindReg },
+        { kind: OperandKind2.Register, value: continueConstReg }
+      ],
+      isContinueReg
+    );
+    const continueDispatchBlock = this.fnBuilder.createBlock("finally_continue_dispatch");
+    this.currentBlock.setTerminator({ kind: "branch", condition: isContinueReg, targets: [continueDispatchBlock.id, normalTargetId] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = continueDispatchBlock;
+    this.emitCompletionTargetDispatch(context, "continue", normalTargetId);
+  }
+  bindCatchVariable(catchClause, exceptionLocal) {
+    if (!catchClause.variableDeclaration) {
+      return;
+    }
+    const exceptionValue = this.loadFromLocal(exceptionLocal);
+    this.bindPattern(catchClause.variableDeclaration.name, exceptionValue, "declare");
+  }
+  lowerTryCatchStatement(stmt) {
+    if (!stmt.catchClause) {
+      this.failUnsupported(stmt, "try without catch requires finally support");
+    }
+    const exceptionLocal = this.createTempLocal("try_exception");
+    const tryBlock = this.fnBuilder.createBlock("try_body");
+    const catchBlock = this.fnBuilder.createBlock("try_catch");
+    const endBlock = this.fnBuilder.createBlock("try_end");
+    this.currentBlock.setTerminator({ kind: "jump", targets: [tryBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = tryBlock;
+    this.currentBlock.addInstruction(OpCode2.TryCatchBegin, [
+      { kind: OperandKind2.BlockLabel, value: catchBlock.id },
+      { kind: OperandKind2.BlockLabel, value: catchBlock.id },
+      { kind: OperandKind2.Register, value: exceptionLocal }
+    ]);
+    this.visitStatement(stmt.tryBlock);
+    if (!this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw") {
+      this.currentBlock.setTerminator({ kind: "jump", targets: [endBlock.id] });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+    }
+    this.currentBlock = catchBlock;
+    this.bindCatchVariable(stmt.catchClause, exceptionLocal);
+    this.visitStatement(stmt.catchClause.block);
+    if (!this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw") {
+      this.currentBlock.setTerminator({ kind: "jump", targets: [endBlock.id] });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+    }
+    this.currentBlock = endBlock;
+  }
+  lowerTryFinallyStatement(stmt) {
+    const finallyBlock = this.fnBuilder.createBlock("try_finally");
+    const afterBlock = this.fnBuilder.createBlock("try_end");
+    const completion = this.createFinallyContext(finallyBlock.id);
+    const tryBlock = this.fnBuilder.createBlock("try_body");
+    const tryExceptionLocal = this.createTempLocal("try_exception");
+    const tryExceptionBlock = this.fnBuilder.createBlock("try_exception");
+    const catchClause = stmt.catchClause;
+    const catchBlock = catchClause ? this.fnBuilder.createBlock("try_catch") : void 0;
+    const catchExceptionLocal = catchClause ? this.createTempLocal("catch_exception") : void 0;
+    const catchExceptionBlock = catchClause ? this.fnBuilder.createBlock("catch_exception") : void 0;
+    this.currentBlock.setTerminator({ kind: "jump", targets: [tryBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = tryBlock;
+    this.currentBlock.addInstruction(OpCode2.TryCatchBegin, [
+      { kind: OperandKind2.BlockLabel, value: catchBlock?.id ?? tryExceptionBlock.id },
+      { kind: OperandKind2.BlockLabel, value: catchBlock?.id ?? tryExceptionBlock.id },
+      { kind: OperandKind2.Register, value: tryExceptionLocal }
+    ]);
+    if (catchBlock) {
+      this.withFinallyContext(completion, () => this.withPassthroughThrow(() => this.visitStatement(stmt.tryBlock)));
+    } else {
+      this.withFinallyContext(completion, () => this.visitStatement(stmt.tryBlock));
+    }
+    if (!this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw") {
+      this.setFinallyCompletion(completion, 0);
+      this.currentBlock.setTerminator({ kind: "jump", targets: [finallyBlock.id] });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+    }
+    if (catchBlock && catchClause && catchExceptionLocal && catchExceptionBlock) {
+      this.currentBlock = catchBlock;
+      this.bindCatchVariable(catchClause, tryExceptionLocal);
+      this.currentBlock.addInstruction(OpCode2.TryCatchBegin, [
+        { kind: OperandKind2.BlockLabel, value: catchExceptionBlock.id },
+        { kind: OperandKind2.BlockLabel, value: catchExceptionBlock.id },
+        { kind: OperandKind2.Register, value: catchExceptionLocal }
+      ]);
+      this.withFinallyContext(completion, () => this.visitStatement(catchClause.block));
+      if (!this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw") {
+        this.setFinallyCompletion(completion, 0);
+        this.currentBlock.setTerminator({ kind: "jump", targets: [finallyBlock.id] });
+        this.fnBuilder.addBlock(this.currentBlock.build());
+      }
+      this.currentBlock = catchExceptionBlock;
+      this.setFinallyCompletion(completion, 2, this.loadFromLocal(catchExceptionLocal));
+      this.currentBlock.setTerminator({ kind: "jump", targets: [finallyBlock.id] });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+    }
+    this.currentBlock = tryExceptionBlock;
+    this.setFinallyCompletion(completion, 2, this.loadFromLocal(tryExceptionLocal));
+    this.currentBlock.setTerminator({ kind: "jump", targets: [finallyBlock.id] });
+    this.fnBuilder.addBlock(this.currentBlock.build());
+    this.currentBlock = finallyBlock;
+    this.visitStatement(stmt.finallyBlock);
+    if (!this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw") {
+      this.emitCompletionDispatch(completion, afterBlock.id);
+    }
+    this.currentBlock = afterBlock;
+  }
+  lowerConditionalExpression(conditionReg, whenTrue, whenFalse) {
+    const self = this;
+    return lowerConditionalExpression(self, conditionReg, whenTrue, whenFalse);
+  }
+  lowerNullishCoalesce(leftReg, rightExpr) {
+    return lowerNullishCoalesce(this, leftReg, rightExpr);
+  }
+  lowerTemplateExpression(expr) {
+    return lowerTemplateExpression(this, expr);
+  }
+  lowerNestedFunctionNode(expr, explicitName) {
+    return this.lowerNestedFunctionLike(expr, explicitName);
+  }
+  visitExpression(expr) {
+    return visitExpression(this, expr);
+  }
+  getPropertyNameText(name) {
+    if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) {
+      return name.text;
+    }
+    this.failUnsupported(name, "Unsupported property name");
+  }
+  materializeArgumentArray(args) {
+    const arrayReg = this.fnBuilder.allocRegister();
+    this.currentBlock.addInstruction(OpCode2.ArrayNew, [], arrayReg);
+    args.forEach((arg) => {
+      if (ts3.isSpreadElement(arg)) {
+        const spreadReg = this.visitExpression(arg.expression);
+        this.emitSpreadInto(arrayReg, spreadReg);
+        return;
+      }
+      const valueReg = this.visitExpression(arg);
+      this.currentBlock.addInstruction(
+        OpCode2.CallMethod,
+        [
+          { kind: OperandKind2.Register, value: arrayReg },
+          { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "push") },
+          { kind: OperandKind2.Register, value: valueReg }
+        ],
+        this.fnBuilder.allocRegister()
+      );
+    });
+    return arrayReg;
+  }
+  parseAssignmentTargetWithDefault(expr) {
+    const normalized = this.normalizeExpression(expr);
+    if (ts3.isBinaryExpression(normalized) && normalized.operatorToken.kind === ts3.SyntaxKind.EqualsToken) {
+      return { target: normalized.left, initializer: normalized.right };
+    }
+    return { target: normalized };
+  }
+  storeArrayPattern(target, sourceReg) {
+    target.elements.forEach((element, index) => {
+      if (ts3.isOmittedExpression(element)) {
+        return;
+      }
+      if (ts3.isSpreadElement(element)) {
+        this.storeValue(element.expression, this.emitArraySlice(sourceReg, index));
+        return;
+      }
+      const { target: nestedTarget, initializer } = this.parseAssignmentTargetWithDefault(element);
+      const valueReg = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(
+        OpCode2.ComputedGet,
+        [
+          { kind: OperandKind2.Register, value: sourceReg },
+          { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.Number, index) }
+        ],
+        valueReg
+      );
+      this.storeValue(nestedTarget, this.applyDefaultValue(valueReg, initializer));
+    });
+  }
+  storeObjectPattern(target, sourceReg) {
+    const excludedKeys = [];
+    let restTarget;
+    for (const property of target.properties) {
+      if (ts3.isSpreadAssignment(property)) {
+        restTarget = property.expression;
+        continue;
+      }
+      if (!ts3.isPropertyAssignment(property) && !ts3.isShorthandPropertyAssignment(property)) {
+        this.failUnsupported(property, "Unsupported object assignment target");
+      }
+      const keyReg = ts3.isComputedPropertyName(property.name) ? this.visitExpression(property.name.expression) : this.emitConstant(ConstantKind2.String, this.getPropertyNameText(property.name));
+      excludedKeys.push(keyReg);
+      const valueReg = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(
+        OpCode2.PropGet,
+        [
+          { kind: OperandKind2.Register, value: sourceReg },
+          { kind: OperandKind2.Register, value: keyReg }
+        ],
+        valueReg
+      );
+      if (ts3.isShorthandPropertyAssignment(property)) {
+        this.storeValue(property.name, this.applyDefaultValue(valueReg, property.objectAssignmentInitializer));
+        continue;
+      }
+      const { target: nestedTarget, initializer } = this.parseAssignmentTargetWithDefault(property.initializer);
+      this.storeValue(nestedTarget, this.applyDefaultValue(valueReg, initializer));
+    }
+    if (restTarget) {
+      const restReg = this.fnBuilder.allocRegister();
+      this.currentBlock.addInstruction(OpCode2.ObjectNew, [], restReg);
+      this.emitSpreadInto(restReg, sourceReg);
+      excludedKeys.forEach((keyReg) => {
+        this.currentBlock.addInstruction(OpCode2.Delete, [
+          { kind: OperandKind2.Register, value: restReg },
+          { kind: OperandKind2.Register, value: keyReg }
+        ]);
+      });
+      this.storeValue(restTarget, restReg);
+    }
+  }
+  visitStatement(stmt) {
+    if (ts3.isBlock(stmt)) {
+      this.scope = new ScopeMap(this.scope);
+      try {
+        stmt.statements.forEach((s) => this.visitStatement(s));
+      } finally {
+        this.scope = this.scope.parent;
+      }
+    } else if (ts3.isFunctionDeclaration(stmt) && stmt.name) {
+      const boxed = this.capturedLocals.has(stmt.name.text);
+      const localReg = this.scope.get(stmt.name.text)?.register ?? this.fnBuilder.addLocal(stmt.name.text, IRType.Any);
+      this.scope.set(stmt.name.text, { register: localReg, boxed });
+      const closureReg = this.lowerNestedFunctionNode(stmt, stmt.name.text);
+      if (boxed) {
+        this.currentBlock.addInstruction(OpCode2.CellNew, [{ kind: OperandKind2.Register, value: closureReg }], localReg);
+        this.fnBuilder.addCapturedVariable(stmt.name.text);
+      } else {
+        this.currentBlock.addInstruction(OpCode2.StoreLocal, [
+          { kind: OperandKind2.Register, value: localReg },
+          { kind: OperandKind2.Register, value: closureReg }
+        ]);
+      }
+    } else if (ts3.isClassDeclaration(stmt) && stmt.name) {
+      this.lowerClassLike(stmt);
+    } else if (ts3.isVariableStatement(stmt)) {
+      stmt.declarationList.declarations.forEach((decl) => {
+        this.initializeVariableDeclaration(decl);
+      });
+    } else if (ts3.isExpressionStatement(stmt)) {
+      this.visitExpression(stmt.expression);
+    } else if (ts3.isReturnStatement(stmt)) {
+      const valReg = stmt.expression ? this.visitExpression(stmt.expression) : this.emitConstant(ConstantKind2.Undefined, null);
+      if (this.getActiveFinallyContext()) {
+        this.routeAbruptCompletionThroughFinally(1, valReg);
+      } else {
+        this.currentBlock.setTerminator({ kind: "return", targets: [], returnValue: valReg });
+        const nextBlock = this.fnBuilder.createBlock("unreachable");
+        this.fnBuilder.addBlock(this.currentBlock.build());
+        this.currentBlock = nextBlock;
+      }
+    } else if (ts3.isThrowStatement(stmt)) {
+      const valueReg = stmt.expression ? this.visitExpression(stmt.expression) : this.emitConstant(ConstantKind2.Undefined, null);
+      if (this.getActiveFinallyContext()) {
+        this.routeAbruptCompletionThroughFinally(2, valueReg);
+      } else {
+        this.currentBlock.setTerminator({ kind: "throw", targets: [], returnValue: valueReg });
+        const nextBlock = this.fnBuilder.createBlock("unreachable");
+        this.fnBuilder.addBlock(this.currentBlock.build());
+        this.currentBlock = nextBlock;
+      }
+    } else if (ts3.isBreakStatement(stmt)) {
+      const target = this.breakTargets[this.breakTargets.length - 1];
+      if (!target) {
+        this.failUnsupported(stmt, "break used outside a loop or switch");
+      }
+      if (this.getActiveFinallyContext()) {
+        this.routeAbruptCompletionThroughFinally(3, void 0, { kind: "break", blockId: target });
+      } else {
+        this.emitJumpAndAdvance(target, "after_break");
+      }
+    } else if (ts3.isContinueStatement(stmt)) {
+      const target = this.continueTargets[this.continueTargets.length - 1];
+      if (!target) {
+        this.failUnsupported(stmt, "continue used outside a loop");
+      }
+      if (this.getActiveFinallyContext()) {
+        this.routeAbruptCompletionThroughFinally(4, void 0, { kind: "continue", blockId: target });
+      } else {
+        this.emitJumpAndAdvance(target, "after_continue");
+      }
+    } else if (ts3.isForStatement(stmt)) {
+      this.scope = new ScopeMap(this.scope);
+      try {
+        if (stmt.initializer) {
+          if (ts3.isVariableDeclarationList(stmt.initializer)) {
+            stmt.initializer.declarations.forEach((decl) => this.initializeVariableDeclaration(decl));
+          } else {
+            this.visitExpression(stmt.initializer);
+          }
+        }
+        const condBlock = this.fnBuilder.createBlock("for_cond");
+        const bodyBlock = this.fnBuilder.createBlock("for_body");
+        const continueBlock = this.fnBuilder.createBlock("for_continue");
+        const endBlock = this.fnBuilder.createBlock("for_end");
+        this.currentBlock.setTerminator({ kind: "jump", targets: [condBlock.id] });
+        this.fnBuilder.addBlock(this.currentBlock.build());
+        this.currentBlock = condBlock;
+        if (stmt.condition) {
+          const condReg = this.visitExpression(stmt.condition);
+          this.currentBlock.setTerminator({ kind: "branch", condition: condReg, targets: [bodyBlock.id, endBlock.id] });
+        } else {
+          this.currentBlock.setTerminator({ kind: "jump", targets: [bodyBlock.id] });
+        }
+        this.fnBuilder.addBlock(this.currentBlock.build());
+        this.enterBreakTarget(endBlock.id);
+        this.enterContinueTarget(continueBlock.id);
+        this.currentBlock = bodyBlock;
+        this.visitStatement(stmt.statement);
+        const bodyFallsThrough = !this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw";
+        if (bodyFallsThrough) {
+          this.currentBlock.setTerminator({ kind: "jump", targets: [continueBlock.id] });
+          this.fnBuilder.addBlock(this.currentBlock.build());
+        }
+        this.currentBlock = continueBlock;
+        if (stmt.incrementor) {
+          this.visitExpression(stmt.incrementor);
+        }
+        this.currentBlock.setTerminator({ kind: "jump", targets: [condBlock.id] });
+        this.fnBuilder.addBlock(this.currentBlock.build());
+        this.leaveContinueTarget();
+        this.leaveBreakTarget();
+        this.currentBlock = endBlock;
+      } finally {
+        this.scope = this.scope.parent;
+      }
+    } else if (ts3.isForOfStatement(stmt)) {
+      this.scope = new ScopeMap(this.scope);
+      try {
+        const iterableReg = this.visitExpression(stmt.expression);
+        const symbolReg = this.resolveVar("Symbol");
+        const iteratorKeyReg = this.emitConstant(ConstantKind2.String, stmt.awaitModifier ? "asyncIterator" : "iterator");
+        const iteratorSymbolReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.PropGet,
+          [
+            { kind: OperandKind2.Register, value: symbolReg },
+            { kind: OperandKind2.Register, value: iteratorKeyReg }
+          ],
+          iteratorSymbolReg
+        );
+        const iteratorMethodReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.ComputedGet,
+          [
+            { kind: OperandKind2.Register, value: iterableReg },
+            { kind: OperandKind2.Register, value: iteratorSymbolReg }
+          ],
+          iteratorMethodReg
+        );
+        const iteratorLocal = this.createTempLocal("forof_iter");
+        const iteratorReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.CallMethod,
+          [
+            { kind: OperandKind2.Register, value: iteratorMethodReg },
+            { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "call") },
+            { kind: OperandKind2.Register, value: iterableReg }
+          ],
+          iteratorReg
+        );
+        this.currentBlock.addInstruction(OpCode2.StoreLocal, [
+          { kind: OperandKind2.Register, value: iteratorLocal },
+          { kind: OperandKind2.Register, value: iteratorReg }
+        ]);
+        const stepLocal = this.createTempLocal("forof_step");
+        const condBlock = this.fnBuilder.createBlock("forof_cond");
+        const bodyBlock = this.fnBuilder.createBlock("forof_body");
+        const endBlock = this.fnBuilder.createBlock("forof_end");
+        this.currentBlock.setTerminator({ kind: "jump", targets: [condBlock.id] });
+        this.fnBuilder.addBlock(this.currentBlock.build());
+        this.currentBlock = condBlock;
+        const liveIteratorReg = this.loadFromLocal(iteratorLocal);
+        const stepReg = this.fnBuilder.allocRegister();
+        if (stmt.awaitModifier) {
+          const nextPromiseReg = this.fnBuilder.allocRegister();
+          this.currentBlock.addInstruction(
+            OpCode2.CallMethod,
+            [
+              { kind: OperandKind2.Register, value: liveIteratorReg },
+              { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "next") }
+            ],
+            nextPromiseReg
+          );
+          this.currentBlock.addInstruction(OpCode2.Await, [{ kind: OperandKind2.Register, value: nextPromiseReg }], stepReg);
+        } else {
+          this.currentBlock.addInstruction(
+            OpCode2.CallMethod,
+            [
+              { kind: OperandKind2.Register, value: liveIteratorReg },
+              { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "next") }
+            ],
+            stepReg
+          );
+        }
+        this.currentBlock.addInstruction(OpCode2.StoreLocal, [
+          { kind: OperandKind2.Register, value: stepLocal },
+          { kind: OperandKind2.Register, value: stepReg }
+        ]);
+        const doneReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.PropGet,
+          [
+            { kind: OperandKind2.Register, value: stepReg },
+            { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "done") }
+          ],
+          doneReg
+        );
+        this.currentBlock.setTerminator({ kind: "branch", condition: doneReg, targets: [endBlock.id, bodyBlock.id] });
+        this.fnBuilder.addBlock(this.currentBlock.build());
+        this.enterBreakTarget(endBlock.id);
+        this.enterContinueTarget(condBlock.id);
+        this.currentBlock = bodyBlock;
+        const liveStepReg = this.loadFromLocal(stepLocal);
+        const valueReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.PropGet,
+          [
+            { kind: OperandKind2.Register, value: liveStepReg },
+            { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "value") }
+          ],
+          valueReg
+        );
+        this.assignLoopBinding(stmt.initializer, valueReg, "for...of");
+        this.visitStatement(stmt.statement);
+        const bodyFallsThrough = !this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw";
+        if (bodyFallsThrough) {
+          this.currentBlock.setTerminator({ kind: "jump", targets: [condBlock.id] });
+          this.fnBuilder.addBlock(this.currentBlock.build());
+        }
+        this.leaveContinueTarget();
+        this.leaveBreakTarget();
+        this.currentBlock = endBlock;
+      } finally {
+        this.scope = this.scope.parent;
+      }
+    } else if (ts3.isForInStatement(stmt)) {
+      this.scope = new ScopeMap(this.scope);
+      try {
+        const sourceReg = this.visitExpression(stmt.expression);
+        const objectReg = this.resolveVar("Object");
+        const keysReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.CallMethod,
+          [
+            { kind: OperandKind2.Register, value: objectReg },
+            { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "keys") },
+            { kind: OperandKind2.Register, value: sourceReg }
+          ],
+          keysReg
+        );
+        const keysLocal = this.createTempLocal("forin_keys");
+        this.currentBlock.addInstruction(OpCode2.StoreLocal, [
+          { kind: OperandKind2.Register, value: keysLocal },
+          { kind: OperandKind2.Register, value: keysReg }
+        ]);
+        const indexLocal = this.createTempLocal("forin_index");
+        const zeroReg = this.emitConstant(ConstantKind2.Number, 0);
+        this.currentBlock.addInstruction(OpCode2.StoreLocal, [
+          { kind: OperandKind2.Register, value: indexLocal },
+          { kind: OperandKind2.Register, value: zeroReg }
+        ]);
+        const condBlock = this.fnBuilder.createBlock("forin_cond");
+        const bodyBlock = this.fnBuilder.createBlock("forin_body");
+        const continueBlock = this.fnBuilder.createBlock("forin_continue");
+        const endBlock = this.fnBuilder.createBlock("forin_end");
+        this.currentBlock.setTerminator({ kind: "jump", targets: [condBlock.id] });
+        this.fnBuilder.addBlock(this.currentBlock.build());
+        this.currentBlock = condBlock;
+        const liveKeysReg = this.loadFromLocal(keysLocal);
+        const liveIndexReg = this.loadFromLocal(indexLocal);
+        const lengthReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.PropGet,
+          [
+            { kind: OperandKind2.Register, value: liveKeysReg },
+            { kind: OperandKind2.Register, value: this.emitConstant(ConstantKind2.String, "length") }
+          ],
+          lengthReg
+        );
+        const condReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.Lt,
+          [
+            { kind: OperandKind2.Register, value: liveIndexReg },
+            { kind: OperandKind2.Register, value: lengthReg }
+          ],
+          condReg
+        );
+        this.currentBlock.setTerminator({ kind: "branch", condition: condReg, targets: [bodyBlock.id, endBlock.id] });
+        this.fnBuilder.addBlock(this.currentBlock.build());
+        this.enterBreakTarget(endBlock.id);
+        this.enterContinueTarget(continueBlock.id);
+        this.currentBlock = bodyBlock;
+        const bodyKeysReg = this.loadFromLocal(keysLocal);
+        const bodyIndexReg = this.loadFromLocal(indexLocal);
+        const keyReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.ComputedGet,
+          [
+            { kind: OperandKind2.Register, value: bodyKeysReg },
+            { kind: OperandKind2.Register, value: bodyIndexReg }
+          ],
+          keyReg
+        );
+        this.assignLoopBinding(stmt.initializer, keyReg, "for...in");
+        this.visitStatement(stmt.statement);
+        const bodyFallsThrough = !this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw";
+        if (bodyFallsThrough) {
+          this.currentBlock.setTerminator({ kind: "jump", targets: [continueBlock.id] });
+          this.fnBuilder.addBlock(this.currentBlock.build());
+        }
+        this.currentBlock = continueBlock;
+        const continueIndexReg = this.loadFromLocal(indexLocal);
+        const oneReg = this.emitConstant(ConstantKind2.Number, 1);
+        const nextIndexReg = this.fnBuilder.allocRegister();
+        this.currentBlock.addInstruction(
+          OpCode2.Add,
+          [
+            { kind: OperandKind2.Register, value: continueIndexReg },
+            { kind: OperandKind2.Register, value: oneReg }
+          ],
+          nextIndexReg
+        );
+        this.currentBlock.addInstruction(OpCode2.StoreLocal, [
+          { kind: OperandKind2.Register, value: indexLocal },
+          { kind: OperandKind2.Register, value: nextIndexReg }
+        ]);
+        this.currentBlock.setTerminator({ kind: "jump", targets: [condBlock.id] });
+        this.fnBuilder.addBlock(this.currentBlock.build());
+        this.leaveContinueTarget();
+        this.leaveBreakTarget();
+        this.currentBlock = endBlock;
+      } finally {
+        this.scope = this.scope.parent;
+      }
+    } else if (ts3.isIfStatement(stmt)) {
+      const conditionReg = this.visitExpression(stmt.expression);
+      const trueBlock = this.fnBuilder.createBlock("if_true");
+      const falseBlock = this.fnBuilder.createBlock(stmt.elseStatement ? "if_false" : "if_end");
+      const endBlock = stmt.elseStatement ? this.fnBuilder.createBlock("if_end") : falseBlock;
+      trueBlock.addPredecessor(this.currentBlock.id);
+      falseBlock.addPredecessor(this.currentBlock.id);
+      this.currentBlock.setTerminator({ kind: "branch", condition: conditionReg, targets: [trueBlock.id, falseBlock.id] });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+      this.currentBlock = trueBlock;
+      this.visitStatement(stmt.thenStatement);
+      const thenFallsThrough = !this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return";
+      if (thenFallsThrough) {
+        if (this.currentBlock.getTerminatorKind() === void 0 || this.currentBlock.getTerminatorKind() === "unreachable") {
+          this.currentBlock.setTerminator({ kind: "jump", targets: [endBlock.id] });
+        }
+        endBlock.addPredecessor(this.currentBlock.id);
+        this.fnBuilder.addBlock(this.currentBlock.build());
+      }
+      if (stmt.elseStatement) {
+        this.currentBlock = falseBlock;
+        this.visitStatement(stmt.elseStatement);
+        const elseFallsThrough = !this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return";
+        if (elseFallsThrough) {
+          if (this.currentBlock.getTerminatorKind() === void 0 || this.currentBlock.getTerminatorKind() === "unreachable") {
+            this.currentBlock.setTerminator({ kind: "jump", targets: [endBlock.id] });
+          }
+          endBlock.addPredecessor(this.currentBlock.id);
+          this.fnBuilder.addBlock(this.currentBlock.build());
+        }
+      } else {
+        endBlock.addPredecessor(falseBlock.id);
+      }
+      this.currentBlock = endBlock;
+    } else if (ts3.isWhileStatement(stmt)) {
+      const condBlock = this.fnBuilder.createBlock("while_cond");
+      const bodyBlock = this.fnBuilder.createBlock("while_body");
+      const endBlock = this.fnBuilder.createBlock("while_end");
+      this.currentBlock.setTerminator({ kind: "jump", targets: [condBlock.id] });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+      this.currentBlock = condBlock;
+      const condReg = this.visitExpression(stmt.expression);
+      this.currentBlock.setTerminator({ kind: "branch", condition: condReg, targets: [bodyBlock.id, endBlock.id] });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+      this.enterBreakTarget(endBlock.id);
+      this.enterContinueTarget(condBlock.id);
+      this.currentBlock = bodyBlock;
+      this.visitStatement(stmt.statement);
+      const bodyFallsThrough = !this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw";
+      if (bodyFallsThrough) {
+        this.currentBlock.setTerminator({ kind: "jump", targets: [condBlock.id] });
+        this.fnBuilder.addBlock(this.currentBlock.build());
+      }
+      this.leaveContinueTarget();
+      this.leaveBreakTarget();
+      this.currentBlock = endBlock;
+    } else if (ts3.isDoStatement(stmt)) {
+      const bodyBlock = this.fnBuilder.createBlock("do_body");
+      const condBlock = this.fnBuilder.createBlock("do_cond");
+      const endBlock = this.fnBuilder.createBlock("do_end");
+      this.currentBlock.setTerminator({ kind: "jump", targets: [bodyBlock.id] });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+      this.enterBreakTarget(endBlock.id);
+      this.enterContinueTarget(condBlock.id);
+      this.currentBlock = bodyBlock;
+      this.visitStatement(stmt.statement);
+      const bodyFallsThrough = !this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw";
+      if (bodyFallsThrough) {
+        this.currentBlock.setTerminator({ kind: "jump", targets: [condBlock.id] });
+        this.fnBuilder.addBlock(this.currentBlock.build());
+      }
+      this.currentBlock = condBlock;
+      const condReg = this.visitExpression(stmt.expression);
+      this.currentBlock.setTerminator({ kind: "branch", condition: condReg, targets: [bodyBlock.id, endBlock.id] });
+      this.fnBuilder.addBlock(this.currentBlock.build());
+      this.leaveContinueTarget();
+      this.leaveBreakTarget();
+      this.currentBlock = endBlock;
+    } else if (ts3.isSwitchStatement(stmt)) {
+      const discriminantReg = this.visitExpression(stmt.expression);
+      const endBlock = this.fnBuilder.createBlock("switch_end");
+      const clauseBlocks = stmt.caseBlock.clauses.map((clause, index) => this.fnBuilder.createBlock(`switch_clause_${index}`));
+      const defaultClauseIndex = stmt.caseBlock.clauses.findIndex((clause) => ts3.isDefaultClause(clause));
+      this.enterBreakTarget(endBlock.id);
+      const checkBlock = this.currentBlock;
+      const caseClauses = stmt.caseBlock.clauses.map((clause, index) => ({ clause, index })).filter((entry) => ts3.isCaseClause(entry.clause));
+      const checkBlocks = caseClauses.slice(1).map((_, index) => this.fnBuilder.createBlock(`switch_check_${index + 1}`));
+      if (caseClauses.length === 0) {
+        checkBlock.setTerminator({
+          kind: "jump",
+          targets: [defaultClauseIndex >= 0 ? clauseBlocks[defaultClauseIndex].id : endBlock.id]
+        });
+        this.fnBuilder.addBlock(checkBlock.build());
+      } else {
+        caseClauses.forEach((entry, index) => {
+          const caseBlock = index === 0 ? checkBlock : checkBlocks[index - 1];
+          if (index > 0) {
+            this.currentBlock = caseBlock;
+          }
+          const caseValueReg = this.visitExpression(entry.clause.expression);
+          const cmpReg = this.fnBuilder.allocRegister();
+          this.currentBlock.addInstruction(
+            OpCode2.StrictEq,
+            [
+              { kind: OperandKind2.Register, value: discriminantReg },
+              { kind: OperandKind2.Register, value: caseValueReg }
+            ],
+            cmpReg
+          );
+          const falseTarget = index === caseClauses.length - 1 ? defaultClauseIndex >= 0 ? clauseBlocks[defaultClauseIndex].id : endBlock.id : checkBlocks[index].id;
+          this.currentBlock.setTerminator({
+            kind: "branch",
+            condition: cmpReg,
+            targets: [clauseBlocks[entry.index].id, falseTarget]
+          });
+          this.fnBuilder.addBlock(this.currentBlock.build());
+        });
+      }
+      stmt.caseBlock.clauses.forEach((clause, index) => {
+        this.currentBlock = clauseBlocks[index];
+        clause.statements.forEach((caseStmt) => this.visitStatement(caseStmt));
+        const fallsThrough = !this.isSyntheticDeadBlock(this.currentBlock) && this.currentBlock.getTerminatorKind() !== "return" && this.currentBlock.getTerminatorKind() !== "throw";
+        if (fallsThrough) {
+          const nextTarget = clauseBlocks[index + 1]?.id ?? endBlock.id;
+          this.currentBlock.setTerminator({ kind: "jump", targets: [nextTarget] });
+          this.fnBuilder.addBlock(this.currentBlock.build());
+        }
+      });
+      this.leaveBreakTarget();
+      this.currentBlock = endBlock;
+    } else if (ts3.isTryStatement(stmt)) {
+      if (stmt.finallyBlock) {
+        this.lowerTryFinallyStatement(stmt);
+      } else {
+        this.lowerTryCatchStatement(stmt);
+      }
+    } else {
+      this.failUnsupported(stmt);
+    }
+  }
+};
+function lowerToIR(moduleInfo, graph, filePath, options = {}) {
+  const modBuilder = new IRModuleBuilder(filePath);
+  for (const imp of moduleInfo.imports) modBuilder.addImport(imp);
+  for (const exp of moduleInfo.exports) modBuilder.addExport(exp);
+  const sourceFile = ts3.createSourceFile(filePath, ts3.sys.readFile(filePath) || "", ts3.ScriptTarget.ESNext, true);
+  const lowerTopLevelFunction = (functionName, functionNode, isExported) => {
+    if (options.skipTopLevelFunctionNames?.has(functionName)) {
+      return;
+    }
+    const jsDoc = ts3.getJSDocTags(functionNode);
+    const isVirtualized = options.forceVirtualizeAll || options.forceVirtualizeFunctionNames?.has(functionName) || jsDoc.some((tag) => ["virtualize", "obfuscate", "protect-critical"].includes(tag.tagName.text)) || functionName === "calculateSecretHash" || functionName === "encryptTEA";
+    const analysis = analyzeFunctionClosures(functionNode, /* @__PURE__ */ new Set());
+    const attributes = [];
+    if (functionNode.modifiers?.some((modifier) => modifier.kind === ts3.SyntaxKind.AsyncKeyword)) {
+      attributes.push(FunctionAttribute.Async);
+    }
+    if ("asteriskToken" in functionNode && !!functionNode.asteriskToken) {
+      attributes.push(FunctionAttribute.Generator);
+    }
+    try {
+      new ASTLowering(modBuilder, functionNode, {
+        name: functionName,
+        isExported,
+        isVirtualized,
+        analysis,
+        attributes
+      });
+    } catch (error) {
+      if (!options.compatibilityFallback) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      const position = sourceFile.getLineAndCharacterOfPosition(functionNode.getStart(sourceFile));
+      options.diagnostics?.push({
+        severity: DiagnosticSeverity.Warning,
+        code: "IR_UNIVERSAL_FALLBACK",
+        message: `Skipped VM lowering for function "${functionName}" due to unsupported syntax: ${message}`,
+        location: {
+          filePath,
+          line: position.line + 1,
+          column: position.character + 1,
+          offset: functionNode.getStart(sourceFile),
+          length: functionNode.getWidth(sourceFile)
+        }
+      });
+    }
+  };
+  ts3.forEachChild(sourceFile, function visit(node) {
+    if (node.parent === sourceFile && ts3.isFunctionDeclaration(node) && node.name) {
+      const isExported = node.modifiers?.some((m) => m.kind === ts3.SyntaxKind.ExportKeyword) ?? false;
+      lowerTopLevelFunction(node.name.text, node, isExported);
+    } else if (node.parent === sourceFile && ts3.isVariableStatement(node)) {
+      const isExported = node.modifiers?.some((modifier) => modifier.kind === ts3.SyntaxKind.ExportKeyword) ?? false;
+      for (const declaration of node.declarationList.declarations) {
+        if (!ts3.isIdentifier(declaration.name) || !declaration.initializer) {
+          continue;
+        }
+        if (ts3.isArrowFunction(declaration.initializer) || ts3.isFunctionExpression(declaration.initializer)) {
+          lowerTopLevelFunction(declaration.name.text, declaration.initializer, isExported);
+          continue;
+        }
+        if (options.compatibilityFallback && options.forceVirtualizeAll) {
+          const position = sourceFile.getLineAndCharacterOfPosition(declaration.getStart(sourceFile));
+          options.diagnostics?.push({
+            severity: DiagnosticSeverity.Warning,
+            code: "IR_UNIVERSAL_FALLBACK",
+            message: `Skipped VM lowering for declaration "${declaration.name.text}" because it is not a function-like initializer`,
+            location: {
+              filePath,
+              line: position.line + 1,
+              column: position.character + 1,
+              offset: declaration.getStart(sourceFile),
+              length: declaration.getWidth(sourceFile)
+            }
+          });
+        }
+      }
+    }
+    ts3.forEachChild(node, visit);
+  });
+  return modBuilder.build();
+}
+
+// src/capabilities.ts
+import ts4 from "typescript";
+var VM_BLOCKERS = /* @__PURE__ */ new Set([
+  ts4.SyntaxKind.DebuggerStatement,
+  ts4.SyntaxKind.WithStatement,
+  ts4.SyntaxKind.ImportKeyword,
+  ts4.SyntaxKind.JsxElement,
+  ts4.SyntaxKind.JsxSelfClosingElement,
+  ts4.SyntaxKind.JsxFragment,
+  ts4.SyntaxKind.JsxExpression,
+  ts4.SyntaxKind.JsxOpeningElement,
+  ts4.SyntaxKind.JsxClosingElement
+]);
+function isFunctionLikeNode(node) {
+  return ts4.isFunctionDeclaration(node) || ts4.isFunctionExpression(node) || ts4.isArrowFunction(node) || ts4.isMethodDeclaration(node) || ts4.isGetAccessorDeclaration(node) || ts4.isSetAccessorDeclaration(node) || ts4.isConstructorDeclaration(node);
+}
+function getFunctionName(node) {
+  if (ts4.isConstructorDeclaration(node)) {
+    return "constructor";
+  }
+  const name = node.name;
+  if (name && (ts4.isIdentifier(name) || ts4.isStringLiteral(name) || ts4.isNumericLiteral(name))) {
+    return name.text;
+  }
+  if (ts4.isVariableDeclaration(node.parent) && ts4.isIdentifier(node.parent.name)) {
+    return node.parent.name.text;
+  }
+  if (ts4.isPropertyAssignment(node.parent)) {
+    const propertyName = node.parent.name;
+    if (ts4.isIdentifier(propertyName) || ts4.isStringLiteral(propertyName) || ts4.isNumericLiteral(propertyName)) {
+      return propertyName.text;
+    }
+  }
+  if (!name) {
+    return "<anonymous>";
+  }
+  return "<computed>";
+}
+function hasLexicalThisProvider(node) {
+  let current = node.parent;
+  while (current) {
+    if (ts4.isMethodDeclaration(current) || ts4.isConstructorDeclaration(current) || ts4.isGetAccessorDeclaration(current) || ts4.isSetAccessorDeclaration(current)) {
+      return true;
+    }
+    if (ts4.isFunctionDeclaration(current) || ts4.isFunctionExpression(current)) {
+      return true;
+    }
+    if (ts4.isPropertyDeclaration(current) && (ts4.isClassDeclaration(current.parent) || ts4.isClassExpression(current.parent))) {
+      return true;
+    }
+    if (ts4.isSourceFile(current)) {
+      return false;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function hasLexicalNewTargetProvider(node) {
+  let current = node.parent;
+  while (current) {
+    if (ts4.isConstructorDeclaration(current)) {
+      return true;
+    }
+    if (ts4.isFunctionDeclaration(current) || ts4.isFunctionExpression(current)) {
+      return true;
+    }
+    if (ts4.isArrowFunction(current)) {
+      current = current.parent;
+      continue;
+    }
+    if (ts4.isMethodDeclaration(current) || ts4.isGetAccessorDeclaration(current) || ts4.isSetAccessorDeclaration(current)) {
+      return false;
+    }
+    if (ts4.isSourceFile(current)) {
+      return false;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function analyzeClassSupport(node) {
+  const reasons = /* @__PURE__ */ new Set();
+  const visit = (current) => {
+    if (ts4.isConstructorDeclaration(current) && current.parameters.some((parameter) => parameter.modifiers?.length)) {
+      reasons.add("class uses parameter properties");
+    }
+    if ((ts4.isMethodDeclaration(current) || ts4.isGetAccessorDeclaration(current) || ts4.isSetAccessorDeclaration(current)) && current.name && ts4.isPrivateIdentifier(current.name)) {
+      reasons.add("class uses unsupported private methods or accessors");
+    }
+    ts4.forEachChild(current, visit);
+  };
+  node.members.forEach((member) => visit(member));
+  return [...reasons];
+}
+function analyzeFunctionNode(node, sourceFile) {
+  const syntaxKinds = /* @__PURE__ */ new Set();
+  const reasons = /* @__PURE__ */ new Set();
+  let tier = "vm_safe";
+  const isAsyncFunction = !!node.modifiers?.some((modifier) => modifier.kind === ts4.SyntaxKind.AsyncKeyword);
+  const visit = (current) => {
+    if (current !== node && isFunctionLikeNode(current)) {
+      return;
+    }
+    if (VM_BLOCKERS.has(current.kind)) {
+      syntaxKinds.add(ts4.SyntaxKind[current.kind]);
+      reasons.add(`contains ${ts4.SyntaxKind[current.kind]}`);
+      if (tier === "vm_safe") {
+        tier = "js_lowered";
+      }
+    }
+    if (ts4.isClassDeclaration(current) || ts4.isClassExpression(current)) {
+      syntaxKinds.add(ts4.SyntaxKind[current.kind]);
+      const classReasons = analyzeClassSupport(current);
+      classReasons.forEach((reason) => reasons.add(reason));
+      if (tier === "vm_safe" && classReasons.length > 0) {
+        tier = "js_lowered";
+      }
+    }
+    if (ts4.isAwaitExpression(current)) {
+      syntaxKinds.add("AwaitExpression");
+      if (!isAsyncFunction) {
+        reasons.add("uses await outside async function");
+        if (tier === "vm_safe") {
+          tier = "js_lowered";
+        }
+      }
+    }
+    if (current.kind === ts4.SyntaxKind.ThisKeyword && ts4.isArrowFunction(node)) {
+      syntaxKinds.add("ThisKeyword");
+      if (!hasLexicalThisProvider(node)) {
+        reasons.add("uses lexical this in arrow function without an enclosing function context");
+      }
+      if (tier === "vm_safe" && !hasLexicalThisProvider(node)) {
+        tier = "js_lowered";
+      }
+    }
+    if (ts4.isMetaProperty(current) && current.keywordToken === ts4.SyntaxKind.NewKeyword && current.name.text === "target" && ts4.isArrowFunction(node)) {
+      syntaxKinds.add("MetaProperty");
+      if (!hasLexicalNewTargetProvider(node)) {
+        reasons.add("uses lexical new.target in arrow function without an enclosing constructor/function context");
+      }
+      if (tier === "vm_safe" && !hasLexicalNewTargetProvider(node)) {
+        tier = "js_lowered";
+      }
+    }
+    ts4.forEachChild(current, visit);
+  };
+  if (node.body) {
+    ts4.forEachChild(node.body, visit);
+  }
+  const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return {
+    filePath: sourceFile.fileName,
+    functionName: getFunctionName(node),
+    tier,
+    startLine: start.line + 1,
+    startColumn: start.character + 1,
+    syntaxKinds: Array.from(syntaxKinds).sort(),
+    reasons: Array.from(reasons).sort()
+  };
+}
+function tryGetTopLevelVariableFunctionBinding(statement) {
+  if (!ts4.isVariableStatement(statement)) {
+    return [];
+  }
+  const bindings = [];
+  for (const declaration of statement.declarationList.declarations) {
+    if (!ts4.isIdentifier(declaration.name) || !declaration.initializer) {
+      continue;
+    }
+    if (ts4.isArrowFunction(declaration.initializer) || ts4.isFunctionExpression(declaration.initializer)) {
+      bindings.push({ name: declaration.name.text, node: declaration.initializer });
+    }
+  }
+  return bindings;
+}
+function analyzeFunctionCapabilities(filePath, sourceText) {
+  const text = sourceText ?? ts4.sys.readFile(filePath) ?? "";
+  const sourceFile = ts4.createSourceFile(filePath, text, ts4.ScriptTarget.ESNext, true);
+  const reports = [];
+  const visit = (node) => {
+    if (isFunctionLikeNode(node)) {
+      reports.push(analyzeFunctionNode(node, sourceFile));
+    }
+    ts4.forEachChild(node, visit);
+  };
+  ts4.forEachChild(sourceFile, visit);
+  return reports;
+}
+function analyzeTopLevelFunctionCapabilities(filePath, sourceText) {
+  const text = sourceText ?? ts4.sys.readFile(filePath) ?? "";
+  const sourceFile = ts4.createSourceFile(filePath, text, ts4.ScriptTarget.ESNext, true);
+  const reports = [];
+  for (const statement of sourceFile.statements) {
+    if (ts4.isFunctionDeclaration(statement) && statement.name) {
+      reports.push(analyzeFunctionNode(statement, sourceFile));
+      continue;
+    }
+    for (const binding of tryGetTopLevelVariableFunctionBinding(statement)) {
+      const report = analyzeFunctionNode(binding.node, sourceFile);
+      reports.push({
+        ...report,
+        functionName: binding.name
+      });
+    }
+  }
+  return reports;
+}
+
+// src/printer.ts
+import { OperandKind as OperandKind3 } from "@tsvm/shared";
+function printIRModule(module) {
+  let out = `Module: ${module.sourceFile}
+`;
+  out += `ID: ${module.id}
+
+`;
+  out += "--- Constant Pool ---\n";
+  for (const c of module.constantPool) {
+    out += `  [${c.index}] ${c.kind} = ${JSON.stringify(c.value)}
+`;
+  }
+  out += "\n";
+  out += "--- Functions ---\n";
+  for (const fn of module.functions) {
+    out += `Function ${fn.name} (${fn.id}) [${fn.attributes.join(", ")}]
+`;
+    out += `  Params: ${fn.params.map((p) => `${p.register} (${p.name})`).join(", ")}
+`;
+    out += `  Locals: ${fn.locals.map((l) => `${l.register} (${l.name})`).join(", ")}
+
+`;
+    for (const block of fn.blocks) {
+      out += `  Block ${block.id} (${block.label}):
+`;
+      for (const inst of block.instructions) {
+        out += `    ${formatInstruction(inst)}
+`;
+      }
+      out += `    ${formatTerminator(block.terminator)}
+
+`;
+    }
+  }
+  return out;
+}
+function formatInstruction(inst) {
+  let out = "";
+  if (inst.result) {
+    out += `${inst.result} = `;
+  }
+  out += `${inst.opcode} `;
+  out += inst.operands.map(formatOperand).join(", ");
+  return out;
+}
+function formatOperand(op) {
+  if (op.kind === OperandKind3.Register) return op.value;
+  if (op.kind === OperandKind3.ConstantIndex) return `c[${op.value}]`;
+  if (op.kind === OperandKind3.Immediate) return String(op.value);
+  if (op.kind === OperandKind3.BlockLabel) return `L_${op.value}`;
+  if (op.kind === OperandKind3.FunctionRef) return `fn_${op.value}`;
+  return String(op.value);
+}
+function formatTerminator(term) {
+  switch (term.kind) {
+    case "return":
+      return `return ${term.returnValue || "void"}`;
+    case "jump":
+      return `jmp ${term.targets[0]}`;
+    case "branch":
+      return `br ${term.condition} ? ${term.targets[0]} : ${term.targets[1]}`;
+    case "unreachable":
+      return "unreachable";
+    default:
+      return `${term.kind} ${term.targets.join(", ")}`;
+  }
+}
+export {
+  ASTLowering,
+  BasicBlockBuilder,
+  IRFunctionBuilder,
+  IRModuleBuilder,
+  analyzeFunctionCapabilities,
+  analyzeTopLevelFunctionCapabilities,
+  createInstruction,
+  createTerminator,
+  lowerToIR,
+  printIRModule
+};