@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/runtime-semantics/LabelledStatement.mts

@@ -0,0 +1,11 @@
+import { JSStringSet } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { LabelledEvaluation } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-labelled-statements-runtime-semantics-evaluation */
+export function Evaluate_LabelledStatement(LabelledStatement: ParseNode.LabelledStatement) {
+  // 1. Let newLabelSet be a new empty List.
+  const newLabelSet = new JSStringSet();
+  // 2. Return LabelledEvaluation of this LabelledStatement with argument newLabelSet.
+  return LabelledEvaluation(LabelledStatement, newLabelSet);
+}

package/src/runtime-semantics/LexicalDeclaration.mts

@@ -0,0 +1,96 @@
+import { Evaluate, type Evaluator } from '../evaluator.mts';
+import {
+  ReturnIfAbrupt,
+  Q, X,
+  type PlainCompletion,
+} from '../completion.mts';
+import { Value } from '../value.mts';
+import { surroundingAgent } from '../engine.mts';
+import {
+  GetValue,
+  InitializeReferencedBinding,
+  ResolveBinding,
+} from '../abstract-ops/all.mts';
+import { IsAnonymousFunctionDefinition, StringValue, type FunctionDeclaration } from '../static-semantics/all.mts';
+import { OutOfRange } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { NamedEvaluation, BindingInitialization } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-let-and-const-declarations-runtime-semantics-evaluation */
+//   LexicalBinding :
+//     BindingIdentifier
+//     BindingIdentifier Initializer
+function* Evaluate_LexicalBinding_BindingIdentifier({ BindingIdentifier, Initializer, strict }: ParseNode.LexicalBinding): Evaluator<PlainCompletion<void>> {
+  if (Initializer) {
+    // 1. Let bindingId be StringValue of BindingIdentifier.
+    const bindingId = StringValue(BindingIdentifier!);
+    // 2. Let lhs be ResolveBinding(bindingId).
+    const lhs = X(ResolveBinding(bindingId, undefined, strict));
+    let value: Value;
+    // 3. If IsAnonymousFunctionDefinition(Initializer) is true, then
+    if (IsAnonymousFunctionDefinition(Initializer)) {
+      // a. Let value be NamedEvaluation of Initializer with argument bindingId.
+      value = Q(yield* NamedEvaluation(Initializer as FunctionDeclaration, bindingId));
+    } else { // 4. Else,
+      // a. Let rhs be the result of evaluating Initializer.
+      const rhs = yield* Evaluate(Initializer);
+      // b. Let value be ? GetValue(rhs).
+      value = Q(GetValue(rhs));
+    }
+    // 5. Return InitializeReferencedBinding(lhs, value).
+    return InitializeReferencedBinding(lhs, value);
+  } else {
+    // 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier).
+    const lhs = ResolveBinding(StringValue(BindingIdentifier!), undefined, strict);
+    // 2. Return InitializeReferencedBinding(lhs, undefined).
+    return InitializeReferencedBinding(lhs, Value.undefined);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-let-and-const-declarations-runtime-semantics-evaluation */
+//   LexicalBinding : BindingPattern Initializer
+function* Evaluate_LexicalBinding_BindingPattern(LexicalBinding: ParseNode.LexicalBinding) {
+  const { BindingPattern, Initializer } = LexicalBinding;
+  const rhs = yield* Evaluate(Initializer!);
+  const value = Q(GetValue(rhs));
+  const env = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  return yield* BindingInitialization(BindingPattern!, value, env);
+}
+
+export function* Evaluate_LexicalBinding(LexicalBinding: ParseNode.LexicalBinding) {
+  switch (true) {
+    case !!LexicalBinding.BindingIdentifier:
+      return yield* Evaluate_LexicalBinding_BindingIdentifier(LexicalBinding);
+    case !!LexicalBinding.BindingPattern:
+      return yield* Evaluate_LexicalBinding_BindingPattern(LexicalBinding);
+    default:
+      throw new OutOfRange('Evaluate_LexicalBinding', LexicalBinding);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-let-and-const-declarations-runtime-semantics-evaluation */
+//   BindingList : BindingList `,` LexicalBinding
+//
+// (implicit)
+//   BindingList : LexicalBinding
+export function* Evaluate_BindingList(BindingList: ParseNode.BindingList) {
+  // 1. Let next be the result of evaluating BindingList.
+  // 2. ReturnIfAbrupt(next).
+  // 3. Return the result of evaluating LexicalBinding.
+  let next;
+  for (const LexicalBinding of BindingList) {
+    next = yield* Evaluate_LexicalBinding(LexicalBinding);
+    ReturnIfAbrupt(next);
+  }
+  return next;
+}
+
+/** https://tc39.es/ecma262/#sec-let-and-const-declarations-runtime-semantics-evaluation */
+//   LexicalDeclaration : LetOrConst BindingList `;`
+export function* Evaluate_LexicalDeclaration({ BindingList }: ParseNode.LexicalDeclaration): Evaluator<PlainCompletion<void>> {
+  // 1. Let next be the result of evaluating BindingList.
+  // 2. ReturnIfAbrupt(next).
+  ReturnIfAbrupt(yield* Evaluate_BindingList(BindingList));
+  // 3. Return NormalCompletion(empty).
+  return undefined;
+}

package/src/runtime-semantics/Literal.mts

@@ -0,0 +1,36 @@
+import { Value } from '../value.mts';
+import { StringValue, NumericValue } from '../static-semantics/all.mts';
+import { OutOfRange } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { NormalCompletion } from '../completion.mts';
+
+/** https://tc39.es/ecma262/#sec-literals-runtime-semantics-evaluation */
+// Literal :
+//   NullLiteral
+//   BooleanLiteral
+//   NumericLiteral
+//   StringLiteral
+export function Evaluate_Literal(Literal: ParseNode.Literal): NormalCompletion<Value> {
+  switch (Literal.type) {
+    case 'NullLiteral':
+      // 1. Return null.
+      return NormalCompletion(Value.null);
+    case 'BooleanLiteral':
+      // 1. If BooleanLiteral is the token false, return false.
+      if (Literal.value === false) {
+        return NormalCompletion(Value.false);
+      }
+      // 2. If BooleanLiteral is the token true, return true.
+      if (Literal.value === true) {
+        return NormalCompletion(Value.true);
+      }
+      throw new OutOfRange('Evaluate_Literal', Literal);
+    case 'NumericLiteral':
+      // 1. Return the NumericValue of NumericLiteral as defined in 11.8.3.
+      return NormalCompletion(NumericValue(Literal));
+    case 'StringLiteral':
+      return NormalCompletion(StringValue(Literal));
+    default:
+      throw new OutOfRange('Evaluate_Literal', Literal);
+  }
+}

package/src/runtime-semantics/LogicalANDExpression.mts

@@ -0,0 +1,25 @@
+import { Value } from '../value.mts';
+import { GetValue, ToBoolean } from '../abstract-ops/all.mts';
+import { Evaluate, type ExpressionEvaluator } from '../evaluator.mts';
+import { Q, X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-binary-logical-operators-runtime-semantics-evaluation */
+//   LogicalANDExpression :
+//     LogicalANDExpression `&&` BitwiseORExpression
+export function* Evaluate_LogicalANDExpression({ LogicalANDExpression, BitwiseORExpression }: ParseNode.LogicalANDExpression): ExpressionEvaluator {
+  // 1. Let lref be the result of evaluating LogicalANDExpression.
+  const lref = yield* Evaluate(LogicalANDExpression);
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(GetValue(lref));
+  // 3. Let lbool be ! ToBoolean(lval).
+  const lbool = X(ToBoolean(lval));
+  // 4. If lbool is false, return lval.
+  if (lbool === Value.false) {
+    return lval;
+  }
+  // 5. Let rref be the result of evaluating BitwiseORExpression.
+  const rref = yield* Evaluate(BitwiseORExpression);
+  // 6. Return ? GetValue(rref).
+  return Q(GetValue(rref));
+}

package/src/runtime-semantics/LogicalORExpression.mts

@@ -0,0 +1,25 @@
+import { Value } from '../value.mts';
+import { GetValue, ToBoolean } from '../abstract-ops/all.mts';
+import { Evaluate, type ExpressionEvaluator } from '../evaluator.mts';
+import { Q, X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-binary-logical-operators-runtime-semantics-evaluation */
+//   LogicalORExpression :
+//     LogicalORExpression `||` LogicalANDExpression
+export function* Evaluate_LogicalORExpression({ LogicalORExpression, LogicalANDExpression }: ParseNode.LogicalORExpression): ExpressionEvaluator {
+  // 1. Let lref be the result of evaluating LogicalORExpression.
+  const lref = yield* Evaluate(LogicalORExpression);
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(GetValue(lref));
+  // 3. Let lbool be ! ToBoolean(lval).
+  const lbool = X(ToBoolean(lval));
+  // 4. If lbool is false, return lval.
+  if (lbool === Value.true) {
+    return lval;
+  }
+  // 5. Let rref be the result of evaluating LogicalANDExpression.
+  const rref = yield* Evaluate(LogicalANDExpression);
+  // 6. Return ? GetValue(rref).
+  return Q(GetValue(rref));
+}

package/src/runtime-semantics/MV.mts

@@ -0,0 +1,10 @@
+import { F } from '../abstract-ops/all.mts';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-mv-s */
+//   StringNumericLiteral :::
+//     [empty]
+//     StrWhiteSpace
+//     StrWhiteSpace_opt StrNumericLiteral StrWhiteSpace_opt
+export function MV_StringNumericLiteral(StringNumericLiteral: string) {
+  return F(Number(StringNumericLiteral));
+}

package/src/runtime-semantics/MemberExpression.mts

@@ -0,0 +1,73 @@
+import { GetValue, MakePrivateReference, RequireObjectCoercible } from '../abstract-ops/all.mts';
+import { Evaluate, type Evaluator } from '../evaluator.mts';
+import { Q, X, type PlainCompletion } from '../completion.mts';
+import { OutOfRange } from '../helpers.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  EvaluatePropertyAccessWithExpressionKey,
+  EvaluatePropertyAccessWithIdentifierKey,
+} from './all.mts';
+import type { ReferenceRecord } from '#self';
+
+/** https://tc39.es/ecma262/#sec-property-accessors-runtime-semantics-evaluation */
+//   MemberExpression : MemberExpression `[` Expression `]`
+//   CallExpression : CallExpression `[` Expression `]`
+function* Evaluate_MemberExpression_Expression({ strict, MemberExpression, Expression }: ParseNode.MemberExpression): Evaluator<PlainCompletion<ReferenceRecord>> {
+  // 1. Let baseReference be the result of evaluating |MemberExpression|.
+  const baseReference = yield* Evaluate(MemberExpression);
+  // 2. Let baseValue be ? GetValue(baseReference).
+  const baseValue = Q(GetValue(baseReference));
+  // 3. If the code matched by this |MemberExpression| is strict mode code, let strict be true; else let strict be false.
+  // 4. Return ? EvaluatePropertyAccessWithExpressionKey(baseValue, |Expression|, strict).
+  return Q(yield* EvaluatePropertyAccessWithExpressionKey(baseValue, Expression!, strict));
+}
+
+/** https://tc39.es/ecma262/#sec-property-accessors-runtime-semantics-evaluation */
+//   MemberExpression : MemberExpression `.` IdentifierName
+//   CallExpression : CallExpression `.` IdentifierName
+function* Evaluate_MemberExpression_IdentifierName({ strict, MemberExpression, IdentifierName }: ParseNode.MemberExpression): Evaluator<PlainCompletion<ReferenceRecord>> {
+  // 1. Let baseReference be the result of evaluating |MemberExpression|.
+  const baseReference = yield* Evaluate(MemberExpression);
+  // 2. Let baseValue be ? GetValue(baseReference).
+  const baseValue = Q(GetValue(baseReference));
+  // 3. If the code matched by this |MemberExpression| is strict mode code, let strict be true; else let strict be false.
+  // 4. Return ? EvaluatePropertyAccessWithIdentifierKey(baseValue, |IdentifierName|, strict).
+  return Q(EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName!, strict));
+}
+
+/** https://tc39.es/ecma262/#sec-property-accessors-runtime-semantics-evaluation */
+//   MemberExpression : MemberExpression `.` PrivateIdentifier
+//   CallExpression : CallExpression `.` PrivateIdentifier
+function* Evaluate_MemberExpression_PrivateIdentifier({ MemberExpression, PrivateIdentifier }: ParseNode.MemberExpression): Evaluator<PlainCompletion<ReferenceRecord>> {
+  // 1. Let baseReference be the result of evaluating MemberExpression.
+  const baseReference = yield* Evaluate(MemberExpression);
+  // 2. Let baseValue be ? GetValue(baseReference).
+  const baseValue = Q(GetValue(baseReference));
+  // 3. Let bv be ? RequireObjectCoercible(baseValue).
+  const bv = Q(RequireObjectCoercible(baseValue));
+  // 4. Let fieldNameString be the StringValue of PrivateIdentifier.
+  const fieldNameString = StringValue(PrivateIdentifier!);
+  // 5. Return ! MakePrivateReference(bv, fieldNameString).
+  return X(MakePrivateReference(bv, fieldNameString));
+}
+
+/** https://tc39.es/ecma262/#sec-property-accessors-runtime-semantics-evaluation */
+//   MemberExpression :
+//     MemberExpression `[` Expression `]`
+//     MemberExpression `.` IdentifierName
+//   CallExpression :
+//     CallExpression `[` Expression `]`
+//     CallExpression `.` IdentifierName
+export function Evaluate_MemberExpression(MemberExpression: ParseNode.MemberExpression) {
+  switch (true) {
+    case !!MemberExpression.Expression:
+      return Evaluate_MemberExpression_Expression(MemberExpression);
+    case !!MemberExpression.IdentifierName:
+      return Evaluate_MemberExpression_IdentifierName(MemberExpression);
+    case !!MemberExpression.PrivateIdentifier:
+      return Evaluate_MemberExpression_PrivateIdentifier(MemberExpression);
+    default:
+      throw new OutOfRange('Evaluate_MemberExpression', MemberExpression);
+  }
+}

package/src/runtime-semantics/MethodDefinitionEvaluation.mts

@@ -0,0 +1,273 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Value, Descriptor, PrivateName, UndefinedValue, type PropertyKeyValue, ObjectValue, BooleanValue,
+} from '../value.mts';
+import {
+  OrdinaryObjectCreate,
+  OrdinaryFunctionCreate,
+  DefinePropertyOrThrow,
+  SetFunctionName,
+  MakeMethod,
+  sourceTextMatchedBy,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  Q, X,
+  ReturnIfAbrupt,
+  type PlainCompletion,
+} from '../completion.mts';
+import { OutOfRange } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { Evaluator } from '../evaluator.mts';
+import { DefineMethod, Evaluate_PropertyName } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-privateelement-specification-type */
+export class PrivateElementRecord {
+  readonly Key: PrivateName;
+
+  readonly Kind: 'method' | 'accessor' | 'field';
+
+  Value?: Value;
+
+  readonly Get?: FunctionObject | UndefinedValue;
+
+  readonly Set?: FunctionObject | UndefinedValue;
+
+  constructor(init: PrivateElementRecord) {
+    this.Key = init.Key;
+    this.Kind = init.Kind;
+    this.Value = init.Value;
+    this.Get = init.Get;
+    this.Set = init.Set;
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-definemethodproperty */
+function DefineMethodProperty(key: PropertyKeyValue | PrivateName, homeObject: ObjectValue, closure: FunctionObject, enumerable: BooleanValue): PlainCompletion<PrivateElementRecord | undefined> {
+  // 1. If key is a Private Name, then
+  if (key instanceof PrivateName) {
+    // a. Return PrivateElement { [[Key]]: key, [[Kind]]: method, [[Value]]: closure }.
+    return new PrivateElementRecord({
+      Key: key,
+      Kind: 'method',
+      Value: closure,
+    });
+  } else { // 2. Else,
+    // a. Let desc be the PropertyDescriptor { [[Value]]: closure, [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true }.
+    const desc = Descriptor({
+      Value: closure,
+      Writable: Value.true,
+      Enumerable: enumerable,
+      Configurable: Value.true,
+    });
+    // b. Perform ? DefinePropertyOrThrow(homeObject, key, desc).
+    Q(DefinePropertyOrThrow(homeObject, key, desc));
+    // c. Return empty.
+    return undefined;
+  }
+}
+
+// MethodDefinition :
+//   ClassElementName `(` UniqueFormalParameters `)` `{` FunctionBody `}`
+//   `get` ClassElementName `(` `)` `{` FunctionBody `}`
+//   `set` ClassElementName `(` PropertySetParameterList `)` `{` FunctionBody `}`
+function* MethodDefinitionEvaluation_MethodDefinition(MethodDefinition: ParseNode.MethodDefinition, object: ObjectValue, enumerable: BooleanValue): Evaluator<PlainCompletion<PrivateElementRecord | void>> {
+  switch (true) {
+    case !!MethodDefinition.UniqueFormalParameters: {
+      // 1. Let methodDef be ? DefineMethod of MethodDefinition with argument object.
+      const methodDef = Q(yield* DefineMethod(MethodDefinition, object));
+      // 2. Perform ! SetFunctionName(methodDef.[[Closure]], methodDef.[[Key]]).
+      X(SetFunctionName(methodDef.Closure, methodDef.Key));
+      // 3. Return ? DefineMethodProperty(methodDef.[[Key]], object, methodDef.[[Closure]], enumerable).
+      return Q(DefineMethodProperty(methodDef.Key, object, methodDef.Closure, enumerable));
+    }
+    case !!MethodDefinition.PropertySetParameterList: {
+      const { ClassElementName, PropertySetParameterList, FunctionBody } = MethodDefinition;
+      // 1. Let propKey be the result of evaluating ClassElementName.
+      // 2. ReturnIfAbrupt(propKey).
+      const propKey = ReturnIfAbrupt(yield* Evaluate_PropertyName(ClassElementName));
+      // 3. Let scope be the running execution context's LexicalEnvironment.
+      const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+      // 4. Let privateScope be the running execution context's PrivateEnvironment.
+      const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+      // 5. Let sourceText be the source text matched by MethodDefinition.
+      const sourceText = sourceTextMatchedBy(MethodDefinition);
+      // 6. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, PropertySetParameterList, FunctionBody, non-lexical-this, scope, privateScope).
+      const closure = OrdinaryFunctionCreate(surroundingAgent.intrinsic('%Function.prototype%'), sourceText, PropertySetParameterList, FunctionBody, 'non-lexical-this', scope, privateScope);
+      // 7. Perform MakeMethod(closure, object).
+      MakeMethod(closure, object);
+      // 8. Perform SetFunctionName(closure, propKey, "get").
+      SetFunctionName(closure, propKey, Value('set'));
+      // 9. If propKey is a Private Name, then
+      if (propKey instanceof PrivateName) {
+        // a. Return PrivateElement { [[Key]]: propKey, [[Kind]]: accessor, [[Get]]: undefined, [[Set]]: closure }.
+        return new PrivateElementRecord({
+          Key: propKey,
+          Kind: 'accessor',
+          Get: Value.undefined,
+          Set: closure,
+        });
+      } else { // 10. Else,
+        // a. Let desc be the PropertyDescriptor { [[Get]]: closure, [[Enumerable]]: enumerable, [[Configurable]]: true }.
+        const desc = Descriptor({
+          Set: closure,
+          Enumerable: enumerable,
+          Configurable: Value.true,
+        });
+        // b. Perform ? DefinePropertyOrThrow(object, propKey, desc).
+        Q(DefinePropertyOrThrow(object, propKey, desc));
+        // c. Return empty.
+        return undefined;
+      }
+    }
+    case !MethodDefinition.UniqueFormalParameters && !MethodDefinition.PropertySetParameterList: {
+      const { ClassElementName, FunctionBody } = MethodDefinition;
+      // 1. Let propKey be the result of evaluating ClassElementName.
+      // 2. ReturnIfAbrupt(propKey).
+      const propKey = ReturnIfAbrupt(yield* Evaluate_PropertyName(ClassElementName));
+      // 3. Let scope be the running execution context's LexicalEnvironment.
+      const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+      // 4. Let privateScope be the running execution context's PrivateEnvironment.
+      const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+      // 5. Let formalParameterList be an instance of the production FormalParameters : [empty].
+      const formalParameterList: ParseNode.FormalParameters = [];
+      // 6. Let sourceText be the source text matched by MethodDefinition.
+      const sourceText = sourceTextMatchedBy(MethodDefinition);
+      // 7. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, formalParameterList, FunctionBody, non-lexical-this, scope, privateScope).
+      const closure = OrdinaryFunctionCreate(surroundingAgent.intrinsic('%Function.prototype%'), sourceText, formalParameterList, FunctionBody, 'non-lexical-this', scope, privateScope);
+      // 8. Perform MakeMethod(closure, object).
+      MakeMethod(closure, object);
+      // 9. Perform SetFunctionName(closure, propKey, "get").
+      SetFunctionName(closure, propKey, Value('get'));
+      // 10. If propKey is a Private Name, then
+      if (propKey instanceof PrivateName) {
+        return new PrivateElementRecord({
+          Key: propKey,
+          Kind: 'accessor',
+          Get: closure,
+          Set: Value.undefined,
+        });
+      } else { // 11. Else,
+        // a. Let desc be the PropertyDescriptor { [[Get]]: closure, [[Enumerable]]: enumerable, [[Configurable]]: true }.
+        const desc = Descriptor({
+          Get: closure,
+          Enumerable: enumerable,
+          Configurable: Value.true,
+        });
+        // b. Perform ? DefinePropertyOrThrow(object, propKey, desc).
+        Q(DefinePropertyOrThrow(object, propKey, desc));
+        // c. Return empty.
+        return undefined;
+      }
+    }
+    default:
+      throw new OutOfRange('MethodDefinitionEvaluation_MethodDefinition', MethodDefinition);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-async-function-definitions-MethodDefinitionEvaluation */
+//   AsyncMethod :
+//     `async` ClassElementName `(` UniqueFormalParameters `)` `{` AsyncBody `}`
+function* MethodDefinitionEvaluation_AsyncMethod(AsyncMethod: ParseNode.AsyncMethod, object: ObjectValue, enumerable: BooleanValue): Evaluator<PlainCompletion<PrivateElementRecord | void>> {
+  const { ClassElementName, UniqueFormalParameters, AsyncBody } = AsyncMethod;
+  // 1. Let propKey be the result of evaluating ClassElementName.
+  // 2. ReturnIfAbrupt(propKey).
+  const propKey = ReturnIfAbrupt(yield* Evaluate_PropertyName(ClassElementName));
+  // 3. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 4. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 5. Let sourceText be the source text matched by AsyncMethod.
+  const sourceText = sourceTextMatchedBy(AsyncMethod);
+  // 6. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, UniqueFormalParameters, AsyncBody, non-lexical-this, scope, privateScope).
+  const closure = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncFunction.prototype%'), sourceText, UniqueFormalParameters, AsyncBody, 'non-lexical-this', scope, privateScope));
+  // 7. Perform ! MakeMethod(closure, object).
+  X(MakeMethod(closure, object));
+  // 8. Perform ! SetFunctionName(closure, propKey).
+  X(SetFunctionName(closure, propKey));
+  // 9. Return ? DefineMethodProperty(propKey, object, closure, enumerable).
+  return Q(DefineMethodProperty(propKey, object, closure, enumerable));
+}
+
+/** https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation */
+//   GeneratorMethod :
+//     `*` ClassElementName `(` UniqueFormalParameters `)` `{` GeneratorBody `}`
+function* MethodDefinitionEvaluation_GeneratorMethod(GeneratorMethod: ParseNode.GeneratorMethod, object: ObjectValue, enumerable: BooleanValue): Evaluator<PlainCompletion<PrivateElementRecord | undefined>> {
+  const { ClassElementName, UniqueFormalParameters, GeneratorBody } = GeneratorMethod;
+  // 1. Let propKey be the result of evaluating ClassElementName.
+  let propKey = yield* Evaluate_PropertyName(ClassElementName);
+  // 2. ReturnIfAbrupt(propKey).
+  propKey = ReturnIfAbrupt(propKey);
+  // 3. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 4. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 5. Let sourceText be the source text matched by GeneratorMethod.
+  const sourceText = sourceTextMatchedBy(GeneratorMethod);
+  // 6. Let closure be ! OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, UniqueFormalParameters, AsyncBody, non-lexical-this, scope, privateScope).
+  const closure = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype%'), sourceText, UniqueFormalParameters, GeneratorBody, 'non-lexical-this', scope, privateScope));
+  // 7. Perform ! MakeMethod(closure, object).
+  X(MakeMethod(closure, object));
+  // 8. Perform ! SetFunctionName(closure, propKey).
+  X(SetFunctionName(closure, propKey));
+  // 9. Let prototype be OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
+  const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype%'));
+  // 10. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  DefinePropertyOrThrow(closure, Value('prototype'), Descriptor({
+    Value: prototype,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  }));
+  // 11. Return ? DefineMethodProperty(propKey, object, closure, enumerable).
+  return Q(DefineMethodProperty(propKey, object, closure, enumerable));
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgenerator-definitions-propertydefinitionevaluation */
+//   AsyncGeneratorMethod :
+//     `async` `*` PropertyName `(` UniqueFormalParameters `)` `{` AsyncGeneratorBody `}`
+function* MethodDefinitionEvaluation_AsyncGeneratorMethod(AsyncGeneratorMethod: ParseNode.AsyncGeneratorMethod, object: ObjectValue, enumerable: BooleanValue): Evaluator<PlainCompletion<PrivateElementRecord | undefined>> {
+  const { ClassElementName, UniqueFormalParameters, AsyncGeneratorBody } = AsyncGeneratorMethod;
+  // 1. Let propKey be the result of evaluating ClassElementName.
+  let propKey = yield* Evaluate_PropertyName(ClassElementName);
+  // 2. ReturnIfAbrupt(propKey).
+  propKey = ReturnIfAbrupt(propKey);
+  // 3. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 4. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateEnv = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 5. Let sourceText be the source text matched by AsyncGeneratorMethod.
+  const sourceText = sourceTextMatchedBy(AsyncGeneratorMethod);
+  // 6. Let closure be ! OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, UniqueFormalParameters, AsyncGeneratorBody, non-lexical-this, scope, privateScope).
+  const closure = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype%'), sourceText, UniqueFormalParameters, AsyncGeneratorBody, 'non-lexical-this', scope, privateEnv));
+  // 7. Perform ! MakeMethod(closure, object).
+  X(MakeMethod(closure, object));
+  // 9. Perform ! SetFunctionName(closure, propKey).
+  X(SetFunctionName(closure, propKey));
+  // 9. Let prototype be OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
+  const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype.prototype%'));
+  // 10. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  DefinePropertyOrThrow(closure, Value('prototype'), Descriptor({
+    Value: prototype,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  }));
+  // 11. Return ? DefineMethodProperty(propKey, object, closure, enumerable).
+  return Q(DefineMethodProperty(propKey, object, closure, enumerable));
+}
+
+export function MethodDefinitionEvaluation(node: ParseNode.MethodDefinitionLike, object: ObjectValue, enumerable: BooleanValue) {
+  switch (node.type) {
+    case 'MethodDefinition':
+      return MethodDefinitionEvaluation_MethodDefinition(node, object, enumerable);
+    case 'AsyncMethod':
+      return MethodDefinitionEvaluation_AsyncMethod(node, object, enumerable);
+    case 'GeneratorMethod':
+      return MethodDefinitionEvaluation_GeneratorMethod(node, object, enumerable);
+    case 'AsyncGeneratorMethod':
+      return MethodDefinitionEvaluation_AsyncGeneratorMethod(node, object, enumerable);
+    default:
+      throw new OutOfRange('MethodDefinitionEvaluation', node);
+  }
+}

package/src/runtime-semantics/Module.mts

@@ -0,0 +1,15 @@
+import { Value } from '../value.mts';
+import { NormalCompletion } from '../completion.mts';
+import { Evaluate } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-module-semantics-runtime-semantics-evaluation */
+// Module :
+//   [empty]
+//   ModuleBody
+export function* Evaluate_Module({ ModuleBody }: ParseNode.Module) {
+  if (!ModuleBody) {
+    return NormalCompletion(Value.undefined);
+  }
+  return yield* Evaluate(ModuleBody);
+}

package/src/runtime-semantics/ModuleBody.mts

@@ -0,0 +1,10 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { Evaluate_StatementList } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-module-semantics-runtime-semantics-evaluation */
+// ModuleBody : ModuleItemList
+export function Evaluate_ModuleBody({ ModuleItemList }: ParseNode.ModuleBody) {
+  // TODO(ts): ModuleItemList might contain ImportDeclaration or ExportDeclaration which is not accepted by Evaluate_StatementList.
+  // @ts-expect-error
+  return Evaluate_StatementList(ModuleItemList);
+}

package/src/runtime-semantics/MultiplicativeExpression.mts

@@ -0,0 +1,18 @@
+import { Q } from '../completion.mts';
+import type { ExpressionEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { EvaluateStringOrNumericBinaryExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-multiplicative-operators-runtime-semantics-evaluation */
+//   MultiplicativeExpression :
+//     MultiplicativeExpression MultiplicativeOperator ExponentiationExpression
+export function* Evaluate_MultiplicativeExpression({
+  MultiplicativeExpression,
+  MultiplicativeOperator,
+  ExponentiationExpression,
+}: ParseNode.MultiplicativeExpression): ExpressionEvaluator {
+  // 1. Let opText be the source text matched by MultiplicativeOperator.
+  const opText = MultiplicativeOperator;
+  // 2. Return ? EvaluateStringOrNumericBinaryExpression(MultiplicativeExpression, opText, ExponentiationExpression).
+  return Q(yield* EvaluateStringOrNumericBinaryExpression(MultiplicativeExpression, opText, ExponentiationExpression));
+}