@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/ClassExpression.mts

@@ -0,0 +1,24 @@
+import { Value } from '../value.mts';
+import { Q } from '../completion.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import { ClassDefinitionEvaluation, DecoratorListEvaluation } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-class-definitions-runtime-semantics-evaluation */
+// ClassExpression :
+//   `class` ClassTail
+//   `class` BindingIdentifier ClassTail
+export function* Evaluate_ClassExpression(ClassExpression: ParseNode.ClassExpression): ValueEvaluator {
+  const { BindingIdentifier, ClassTail, Decorators } = ClassExpression;
+  const sourceText = ClassExpression.sourceText;
+  const decorators = Decorators ? Q(yield* DecoratorListEvaluation(Decorators)) : [];
+  if (!BindingIdentifier) {
+    // 1. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments undefined and ''
+    return Q(yield* ClassDefinitionEvaluation(ClassTail, Value.undefined, Value(''), sourceText, decorators));
+  }
+  // 1. Let className be StringValue of BindingIdentifier.
+  const className = StringValue(BindingIdentifier);
+  // 2. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments className and className.
+  return Q(yield* ClassDefinitionEvaluation(ClassTail, className, className, sourceText, decorators));
+}

package/src/runtime-semantics/ClassFieldDefinitionEvaluation.mts

@@ -0,0 +1,189 @@
+import { X, Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator, ValueEvaluator } from '../evaluator.mts';
+import { Evaluate_PropertyName } from './PropertyName.mts';
+import {
+  surroundingAgent,
+  CreateBuiltinFunction, DefinePropertyOrThrow, MakeMethod, OrdinaryFunctionCreate, PrivateGet, PrivateSet, SymbolDescriptiveString,
+} from '#self';
+import {
+  ClassElementDefinitionRecord,
+  Descriptor,
+  JSStringValue,
+  SymbolValue,
+  Value,
+  type Arguments,
+  type ECMAScriptFunctionObject, type FunctionCallContext, type FunctionObject, type ObjectValue, PrivateName, type PropertyKeyValue,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-classfielddefinition-record-specification-type */
+export interface ClassFieldDefinitionRecord {
+  readonly Name: PropertyKeyValue | PrivateName;
+  readonly Initializer: ECMAScriptFunctionObject | undefined;
+}
+export const ClassFieldDefinitionRecord = function ClassFieldDefinitionRecord(value: ClassFieldDefinitionRecord) {
+  Object.setPrototypeOf(value, ClassFieldDefinitionRecord.prototype);
+  return value;
+} as {
+  (value: ClassFieldDefinitionRecord): ClassFieldDefinitionRecord;
+  [Symbol.hasInstance](instance: unknown): instance is ClassFieldDefinitionRecord;
+};
+
+export function* ClassFieldDefinitionEvaluation(FieldDefinition: ParseNode.FieldDefinition, homeObject: ObjectValue): PlainEvaluator<ClassFieldDefinitionRecord> {
+  const { ClassElementName, Initializer } = FieldDefinition;
+  // 1. Let name be the result of evaluating ClassElementName.
+  const name = Q(yield* Evaluate_PropertyName(ClassElementName));
+  // 3. If Initializer is present, then
+  let initializer;
+  if (Initializer) {
+    // a. Let formalParameterList be an instance of the production FormalParameters : [empty].
+    const formalParameterList: readonly [] = [];
+    // b. Let scope be the LexicalEnvironment of the running execution context.
+    const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+    // c. Let privateScope be the running execution context's PrivateEnvironment.
+    const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+    // d. Let sourceText be the empty sequence of Unicode code points.
+    const sourceText = '';
+    // e. Let initializer be ! OrdinaryFunctionCreate(%Function.prototype%, sourceText, formalParameterList, Initializer, non-lexical-this, scope, privateScope).
+    initializer = X(OrdinaryFunctionCreate(
+      surroundingAgent.intrinsic('%Function.prototype%'),
+      sourceText,
+      formalParameterList,
+      Initializer,
+      'non-lexical-this',
+      scope,
+      privateScope,
+    ));
+    // f. Perform MakeMethod(initializer, homeObject).
+    MakeMethod(initializer, homeObject);
+    // g. Set initializer.[[ClassFieldInitializerName]] to name.
+    initializer.ClassFieldInitializerName = name;
+  } else { // 4. Else,
+    // a. Let initializer be empty.
+    initializer = undefined;
+  }
+  // 5. Return the ClassFieldDefinition Record { [[Name]]: name, [[Initializer]]: initializer }.
+  return ClassFieldDefinitionRecord({
+    Name: name,
+    Initializer: initializer,
+  });
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-runtime-semantics-classfielddefinitionevaluation */
+export function* ClassFieldDefinitionEvaluation_decorator(FieldDefinition: ParseNode.FieldDefinition, homeObject: ObjectValue): PlainEvaluator<ClassElementDefinitionRecord> {
+  const { ClassElementName, Initializer, accessor } = FieldDefinition;
+
+  if (!accessor) {
+    const name = Q(yield* Evaluate_PropertyName(ClassElementName));
+    const initializers: FunctionObject[] = [];
+    const extraInitializers: FunctionObject[] = [];
+    if (Initializer) {
+      const initializer = CreateFieldInitializerFunction(homeObject, name, Initializer);
+      // TODO(decorator): spec bug. ApplyDecoratorsToElementDefinition unshift decorator initializers into this array, but read it in order, so the spec order is wrong (be like [decorator2, decorator1, syntaxInit], but the correct order should be [syntaxInit, decorator2, decorator1])
+      if (surroundingAgent.feature('decorators.no-bugfix.1')) {
+        initializers.push(initializer);
+      } else {
+        initializers[-1] = initializer;
+      }
+    }
+    return ClassElementDefinitionRecord({
+      Kind: 'field',
+      Key: name,
+      Initializers: initializers,
+      ExtraInitializers: extraInitializers,
+      Decorators: undefined,
+    });
+  } else {
+    const name = Q(yield* Evaluate_PropertyName(ClassElementName));
+    let readableName: JSStringValue;
+    if (name instanceof PrivateName) {
+      readableName = name.Description;
+    } else if (name instanceof SymbolValue) {
+      readableName = SymbolDescriptiveString(name);
+    } else {
+      readableName = name;
+    }
+    const privateStateDesc = `${readableName.stringValue()} accessor storage`;
+    const privateStateName = new PrivateName(Value(privateStateDesc));
+    const getter = MakeAutoAccessorGetter(homeObject, name, privateStateName);
+    const setter = MakeAutoAccessorSetter(homeObject, name, privateStateName);
+    const initializers = [];
+    const extraInitializers: FunctionObject[] = [];
+    if (Initializer) {
+      const initializer = CreateFieldInitializerFunction(homeObject, name, Initializer);
+      // TODO(decorator): spec bug. ApplyDecoratorsToElementDefinition unshift decorator initializers into this array, but read it in order, so the spec order is wrong (be like [decorator2, decorator1, syntaxInit], but the correct order should be [syntaxInit, decorator2, decorator1])
+      if (surroundingAgent.feature('decorators.no-bugfix.1')) {
+        initializers.push(initializer);
+      } else {
+        initializers[-1] = initializer;
+      }
+    }
+    if (!(name instanceof PrivateName)) {
+      const desc = new Descriptor({
+        Getter: getter,
+        Setter: setter,
+        Enumerable: Value.true,
+        Configurable: Value.true,
+      });
+      Q(yield* DefinePropertyOrThrow(homeObject, name, desc));
+    }
+    return ClassElementDefinitionRecord({
+      Kind: 'accessor',
+      Key: name,
+      Get: getter,
+      Set: setter,
+      BackingStorageKey: privateStateName,
+      Initializers: initializers,
+      ExtraInitializers: extraInitializers,
+      Decorators: undefined,
+    });
+  }
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-createfieldinitializerfunction */
+export function CreateFieldInitializerFunction(homeObject: ObjectValue, propName: PropertyKeyValue | PrivateName, Initializer: ParseNode.AssignmentExpressionOrHigher) {
+  const formalParameterList: readonly [] = [];
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  const sourceText = '';
+  const initializer = OrdinaryFunctionCreate(
+    surroundingAgent.intrinsic('%Function.prototype%'),
+    sourceText,
+    formalParameterList,
+    Initializer,
+    'non-lexical-this',
+    scope,
+    privateScope,
+  );
+  MakeMethod(initializer, homeObject);
+  initializer.ClassFieldInitializerName = propName;
+  return initializer;
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-makeautoaccessorgetter */
+export function MakeAutoAccessorGetter(_homeObject: ObjectValue, _name: PropertyKeyValue | PrivateName, privateStateName: PrivateName) {
+  const getterClosure = function* getterClosure(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+    const o = thisValue as ObjectValue;
+    return Q(yield* PrivateGet(o, privateStateName));
+  };
+  const getter = CreateBuiltinFunction(getterClosure, 0, Value('get'), []);
+  // TODO(decorator): spec bug, SetFunctionName only accepts ECMAScriptFunctionObject, but the name is already set when calling CreateBuiltinFunction
+  // SetFunctionName(getter, name, Value('get'));
+  // TODO(decorator): https://github.com/tc39/proposal-decorators/issues/568
+  // MakeMethod(getter, homeObject);
+  return getter;
+}
+
+export function MakeAutoAccessorSetter(_homeObject: ObjectValue, _name: PropertyKeyValue | PrivateName, privateStateName: PrivateName) {
+  const setterClosure = function* setterClosure([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+    const o = thisValue as ObjectValue;
+    Q(yield* PrivateSet(o, privateStateName, value));
+    return Value.undefined;
+  };
+  const setter = CreateBuiltinFunction(setterClosure, 1, Value('set'), []);
+  // TODO(decorator): spec bug
+  // SetFunctionName(setter, name, Value('set'));
+  // TODO(decorator): https://github.com/tc39/proposal-decorators/issues/568
+  // MakeMethod(setter, homeObject);
+  return setter;
+}

package/src/runtime-semantics/ClassStaticBlockDefinitionEvaluation.mts

@@ -0,0 +1,48 @@
+import { X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { surroundingAgent } from '#self';
+import {
+  MakeMethod,
+  OrdinaryFunctionCreate,
+  type ECMAScriptFunctionObject,
+  ObjectValue,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-classstaticblockdefinition-record-specification-type */
+export interface ClassStaticBlockDefinitionRecord {
+  readonly BodyFunction: ECMAScriptFunctionObject;
+}
+export const ClassStaticBlockDefinitionRecord = function ClassStaticBlockDefinitionRecord(value: ClassStaticBlockDefinitionRecord) {
+  Object.setPrototypeOf(value, ClassStaticBlockDefinitionRecord.prototype);
+  return value;
+} as {
+  (value: ClassStaticBlockDefinitionRecord): ClassStaticBlockDefinitionRecord;
+  [Symbol.hasInstance](instance: unknown): instance is ClassStaticBlockDefinitionRecord;
+};
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-classstaticblockdefinitionevaluation */
+//    ClassStaticBlock : `static` `{` ClassStaticBlockBody `}`
+export function ClassStaticBlockDefinitionEvaluation({ ClassStaticBlockBody }: ParseNode.ClassStaticBlock, homeObject: ObjectValue) {
+  // 1. Let lex be the running execution context's LexicalEnvironment.
+  const lex = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 2. Let privateEnv be the running execution context's PrivateEnvironment.
+  const privateEnv = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 3. Let sourceText be the empty sequence of Unicode code points.
+  const sourceText = '';
+  // 4. Let formalParameters be an instance of the production FormalParameters : [empty] .
+  const formalParameters: readonly [] = [];
+  // 5. Let bodyFunction be OrdinaryFunctionCreate(%Function.prototype%, sourceText, formalParameters, ClassStaticBlockBody, non-lexical-this, lex, privateEnv).
+  const bodyFunction = X(OrdinaryFunctionCreate(
+    surroundingAgent.intrinsic('%Function.prototype%'),
+    sourceText,
+    formalParameters,
+    ClassStaticBlockBody,
+    'non-lexical-this',
+    lex,
+    privateEnv,
+  ));
+  // 6. Perform MakeMethod(bodyFunction, homeObject).
+  X(MakeMethod(bodyFunction, homeObject));
+  // 7. Return the ClassStaticBlockDefinition Record { [[BodyFunction]]: bodyFunction }.
+  return ClassStaticBlockDefinitionRecord({ BodyFunction: bodyFunction });
+}

package/src/runtime-semantics/CoalesceExpression.mts

@@ -0,0 +1,24 @@
+import { Q } from '../completion.mts';
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Value } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { GetValue } from '#self';
+
+/** https://tc39.es/ecma262/#sec-binary-logical-operators-runtime-semantics-evaluation */
+//   CoalesceExpression :
+//     CoalesceExpressionHead `??` BitwiseORExpression
+export function* Evaluate_CoalesceExpression({ CoalesceExpressionHead, BitwiseORExpression }: ParseNode.CoalesceExpression): ValueEvaluator {
+  // 1. Let lref be the result of evaluating |CoalesceExpressionHead|.
+  const lref = Q(yield* Evaluate(CoalesceExpressionHead));
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(yield* GetValue(lref));
+  // 3. If lval is *undefined* or *null*,
+  if (lval === Value.undefined || lval === Value.null) {
+    // a. Let rref be the result of evaluating |BitwiseORExpression|.
+    const rref = Q(yield* Evaluate(BitwiseORExpression));
+    // b. Return ? GetValue(rref).
+    return Q(yield* GetValue(rref));
+  }
+  // 4. Otherwise, return lval.
+  return lval;
+}

package/src/runtime-semantics/CommaOperator.mts

@@ -0,0 +1,18 @@
+import { Evaluate } from '../evaluator.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { GetValue } from '#self';
+import type { Value, ValueEvaluator } from '#self';
+
+/** https://tc39.es/ecma262/#sec-comma-operator-runtime-semantics-evaluation */
+//   Expression :
+//     AssignmentExpression
+//     Expression `,` AssignmentExpression
+export function* Evaluate_CommaOperator({ ExpressionList }: ParseNode.CommaOperator): ValueEvaluator {
+  let result!: Value;
+  for (const Expression of ExpressionList) {
+    const lref = Q(yield* Evaluate(Expression));
+    result = Q(yield* GetValue(lref));
+  }
+  return result;
+}

package/src/runtime-semantics/ConditionalExpression.mts

@@ -0,0 +1,31 @@
+import { Value } from '../value.mts';
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Q, X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { ToBoolean, GetValue } from '#self';
+
+/** https://tc39.es/ecma262/#sec-conditional-operator-runtime-semantics-evaluation */
+//   ConditionalExpression :
+//     ShortCircuitExpression `?` AssignmentExpression `:` AssignmentExpression
+export function* Evaluate_ConditionalExpression({
+  ShortCircuitExpression,
+  AssignmentExpression_a,
+  AssignmentExpression_b,
+}: ParseNode.ConditionalExpression): ValueEvaluator {
+  // 1. Let lref be the result of evaluating ShortCircuitExpression.
+  const lref = Q(yield* Evaluate(ShortCircuitExpression));
+  // 2. Let lval be ! ToBoolean(? GetValue(lref)).
+  const lval = X(ToBoolean(Q(yield* GetValue(lref))));
+  // 3. If lval is true, then
+  if (lval === Value.true) {
+    // a. Let trueRef be the result of evaluating the first AssignmentExpression.
+    const trueRef = Q(yield* Evaluate(AssignmentExpression_a));
+    // b. Return ? GetValue(trueRef).
+    return Q(yield* GetValue(trueRef));
+  } else { // 4. Else,
+    // a. Let falseRef be the result of evaluating the second AssignmentExpression.
+    const falseRef = Q(yield* Evaluate(AssignmentExpression_b));
+    // b. Return ? GetValue(falseRef).
+    return Q(yield* GetValue(falseRef));
+  }
+}

package/src/runtime-semantics/ContinueStatement.mts

@@ -0,0 +1,18 @@
+import { Completion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { StringValue } from '../static-semantics/all.mts';
+
+/** https://tc39.es/ecma262/#sec-continue-statement-runtime-semantics-evaluation */
+//   ContinueStatement :
+//     `continue` `;`
+//     `continue` LabelIdentifier `;`
+export function Evaluate_ContinueStatement({ LabelIdentifier }: ParseNode.ContinueStatement) {
+  if (!LabelIdentifier) {
+    // 1. Return Completion { [[Type]]: continue, [[Value]]: empty, [[Target]]: empty }.
+    return new Completion({ Type: 'continue', Value: undefined, Target: undefined });
+  }
+  // 1. Let label be the StringValue of LabelIdentifier.
+  const label = StringValue(LabelIdentifier);
+  // 2. Return Completion { [[Type]]: continue, [[Value]]: empty, [[Target]]: label }.
+  return new Completion({ Type: 'continue', Value: undefined, Target: label });
+}

package/src/runtime-semantics/CreateDynamicFunction.mts

@@ -0,0 +1,161 @@
+import { Q, ThrowCompletion, X } from '../completion.mts';
+import { Parser, wrappedParse } from '../parse.mts';
+import { Token } from '../parser/tokens.mts';
+import {
+  Descriptor, UndefinedValue, Value,
+  type Arguments,
+} from '../value.mts';
+import { __ts_cast__, isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { FunctionKind } from '../parser/FunctionParser.mts';
+import {
+  HostEnsureCanCompileStrings,
+  surroundingAgent,
+} from '#self';
+import {
+  Assert,
+  DefinePropertyOrThrow,
+  GetPrototypeFromConstructor,
+  MakeConstructor,
+  OrdinaryFunctionCreate,
+  OrdinaryObjectCreate,
+  SetFunctionName,
+  ToString,
+  type FunctionObject,
+  type Intrinsics,
+  type ValueEvaluator,
+} from '#self';
+
+export function* CreateDynamicFunction(constructor: FunctionObject, newTarget: FunctionObject | UndefinedValue, kind: 'normal' | 'generator' | 'async' | 'asyncGenerator', parameterArgs: Arguments, bodyArg: Value): ValueEvaluator {
+  if (newTarget instanceof UndefinedValue) {
+    newTarget = constructor;
+  }
+  let fallbackProto: keyof Intrinsics;
+  let prefix;
+  let exprSym;
+  let bodySym;
+  let parameterSym;
+  const bodySymParser = (parser: Parser, await_: boolean, yield_: boolean) => parser.scope.with({
+    await: await_, yield: yield_, lexical: true, variable: true,
+  }, () => parser.parseFunctionBody(await_, yield_, false));
+  const parameterSymParser = (parser: Parser, await_: boolean, yield_: boolean) => parser.scope.with({
+    await: await_, yield: yield_, lexical: true, variable: true, variableFunctions: true, newTarget: true, return: true, label: 'boundary',
+  }, () => ({ result: parser.parseFormalParameters() }));
+  if (kind === 'normal') {
+    prefix = 'function';
+    exprSym = (parser: Parser) => parser.parseFunctionExpression(FunctionKind.NORMAL);
+    bodySym = (parser: Parser) => bodySymParser(parser, false, false);
+    parameterSym = (parser: Parser) => parameterSymParser(parser, false, false);
+    fallbackProto = '%Function.prototype%';
+  } else if (kind === 'generator') {
+    prefix = 'function*';
+    exprSym = (parser: Parser) => parser.parseFunctionExpression(FunctionKind.NORMAL);
+    bodySym = (parser: Parser) => bodySymParser(parser, false, true);
+    parameterSym = (parser: Parser) => parameterSymParser(parser, false, true);
+    fallbackProto = '%GeneratorFunction.prototype%';
+  } else if (kind === 'async') {
+    prefix = 'async function';
+    exprSym = (parser: Parser) => parser.parseFunctionExpression(FunctionKind.ASYNC);
+    bodySym = (parser: Parser) => bodySymParser(parser, true, false);
+    parameterSym = (parser: Parser) => parameterSymParser(parser, true, false);
+    fallbackProto = '%AsyncFunction.prototype%';
+  } else {
+    Assert(kind === 'asyncGenerator');
+    prefix = 'async function*';
+    exprSym = (parser: Parser) => parser.parseFunctionExpression(FunctionKind.ASYNC);
+    bodySym = (parser: Parser) => bodySymParser(parser, true, true);
+    parameterSym = (parser: Parser) => parameterSymParser(parser, true, true);
+    fallbackProto = '%AsyncGeneratorFunction.prototype%';
+  }
+  const argCount = parameterArgs.length;
+  const parameterStrings: string[] = [];
+  for (const arg of parameterArgs) {
+    parameterStrings.push(Q(yield* ToString(arg!)).stringValue());
+  }
+  const bodyString = Q(yield* ToString(bodyArg)).stringValue();
+  const currentRealm = surroundingAgent.currentRealmRecord;
+  Q(yield* HostEnsureCanCompileStrings(currentRealm, parameterStrings, bodyString, false));
+  let P = '';
+  if (argCount > 0) {
+    P = parameterStrings[0];
+    let k = 1;
+    while (k < argCount) {
+      const nextArgString = parameterStrings[k];
+      P = `${P},${nextArgString}`;
+      k += 1;
+    }
+  }
+  const bodyParseString = `\u{000A}${bodyString}\u{000A}`;
+  const sourceString = `${prefix} anonymous(${P}\u{000A}) {${bodyParseString}}`;
+  const sourceText = sourceString;
+  const parameters = wrappedParse({
+    source: `${' '.repeat(prefix.length + 10)}(${P}\n)`,
+    decoratingSource: sourceText,
+  }, (parser) => {
+    const result = parameterSym(parser);
+    parser.expect(Token.EOS);
+    return result;
+  });
+  const body = wrappedParse({
+    source: `${' '.repeat(prefix.length + P.length + 12)}\u{000A} {${bodyParseString}}`,
+    decoratingSource: sourceText,
+  }, (parser) => {
+    const result = bodySym(parser);
+    parser.expect(Token.EOS);
+    return result;
+  });
+  // NOTE: The parameters and body are parsed separately to ensure that each is valid alone. For example, new Function("/*", "*/ ) {") does not evaluate to a function.
+  // NOTE: If this step is reached, sourceText must have the syntax of exprSym (although the reverse implication does not hold). The purpose of the next two steps is to enforce any Early Error rules which apply to exprSym directly.
+  let scriptId: string | undefined;
+  let parametersNode: ParseNode.FormalParameters;
+  let bodyNode;
+  {
+    const expr = wrappedParse({ source: sourceString }, (p) => {
+      const r = exprSym(p);
+      p.expect(Token.EOS);
+      return r;
+    });
+    scriptId = surroundingAgent.addDynamicParsedSource(surroundingAgent.currentRealmRecord, sourceString, expr);
+    if (isArray(parameters)) {
+      Parser.decorateSyntaxErrorWithScriptId(parameters[0], scriptId);
+      return ThrowCompletion(parameters[0]);
+    }
+    if (isArray(body)) {
+      Parser.decorateSyntaxErrorWithScriptId(body[0], scriptId);
+      return ThrowCompletion(body[0]);
+    }
+    if (Array.isArray(expr)) {
+      Parser.decorateSyntaxErrorWithScriptId(expr[0], scriptId);
+      return ThrowCompletion(expr[0]);
+    }
+    parametersNode = parameters.result;
+    bodyNode = body;
+  }
+  const proto = Q(yield* GetPrototypeFromConstructor(newTarget, fallbackProto));
+  const env = currentRealm.GlobalEnv;
+  const privateEnv = null;
+  const F = OrdinaryFunctionCreate(proto, sourceText, parametersNode, bodyNode, 'non-lexical-this', env, privateEnv);
+  F.scriptId = scriptId;
+  SetFunctionName(F, Value('anonymous'));
+  if (kind === 'generator') {
+    const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype%'));
+    X(DefinePropertyOrThrow(F, Value('prototype'), Descriptor({
+      Value: prototype,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+    })));
+  } else if (kind === 'asyncGenerator') {
+    const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype.prototype%'));
+    X(DefinePropertyOrThrow(F, Value('prototype'), Descriptor({
+      Value: prototype,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+    })));
+  } else if (kind === 'normal') {
+    MakeConstructor(F);
+  }
+  // 29. NOTE: Functions whose kind is async are not constructible and do not have a [[Construct]] internal method or a "prototype" property.
+  return F;
+}

package/src/runtime-semantics/DebuggerStatement.mts

@@ -0,0 +1,20 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { surroundingAgent } from '#self';
+import { Assert, type StatementEvaluator } from '#self';
+
+/** https://tc39.es/ecma262/#sec-debugger-statement-runtime-semantics-evaluation */
+// DebuggerStatement : `debugger` `;`
+export function* Evaluate_DebuggerStatement(_node: ParseNode.DebuggerStatement): StatementEvaluator {
+  // 1. If an implementation-defined debugging facility is available and enabled, then
+  if (surroundingAgent.hostDefinedOptions.onDebugger) {
+    // a. Perform an implementation-defined debugging action.
+    // b. Let result be an implementation-defined Completion value.
+    // TODO(debugger): this should respect conditional breakpoints.
+    const completion = yield { suspend: 'debugger' };
+    Assert(completion.resume === 'debugger');
+    return completion.value;
+  }
+  // 2. Return result.
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/DefineMethod.mts

@@ -0,0 +1,42 @@
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import { Evaluate_PropertyName } from './all.mts';
+import {
+  surroundingAgent, OrdinaryFunctionCreate, MakeMethod, sourceTextMatchedBy,
+} from '#self';
+import type {
+  ECMAScriptFunctionObject, ObjectValue, PrivateName, PropertyKeyValue,
+} from '#self';
+
+export interface DefineMethodRecord {
+  readonly Key: PropertyKeyValue | PrivateName;
+  readonly Closure: ECMAScriptFunctionObject;
+}
+/** https://tc39.es/ecma262/#sec-runtime-semantics-definemethod */
+export function* DefineMethod(MethodDefinition: ParseNode.MethodDefinition, object: ObjectValue, functionPrototype?: ObjectValue): PlainEvaluator<DefineMethodRecord> {
+  const { ClassElementName, UniqueFormalParameters, FunctionBody } = MethodDefinition;
+  // 1. Let propKey be the result of evaluating ClassElementName.
+  const propKey = Q(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;
+  let prototype;
+  // 5. If functionPrototype is present as a parameter, then
+  if (functionPrototype !== undefined) {
+    // a. Let prototype be functionPrototype.
+    prototype = functionPrototype;
+  } else { // 6. Else,
+    // a. Let prototype be %Function.prototype%.
+    prototype = surroundingAgent.intrinsic('%Function.prototype%');
+  }
+  // 7. Let sourceText be the source text matched by MethodDefinition.
+  const sourceText = sourceTextMatchedBy(MethodDefinition);
+  // 8. Let closure be OrdinaryFunctionCreate(prototype, sourceText, UniqueFormalParameters, FunctionBody, non-lexical-this, scope, privateScope).
+  const closure = OrdinaryFunctionCreate(prototype, sourceText, UniqueFormalParameters!, FunctionBody, 'non-lexical-this', scope, privateScope);
+  // 9. Perform MakeMethod(closure, object).
+  MakeMethod(closure, object);
+  // 10. Return the Record { [[Key]]: propKey, [[Closure]]: closure }.
+  return { Key: propKey, Closure: closure };
+}