@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/EvaluatePropertyAccess.mts

@@ -0,0 +1,39 @@
+import { Value, ReferenceRecord } from '../value.mts';
+import { Evaluate, type ReferenceEvaluator } from '../evaluator.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { Q, type PlainCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  GetValue,
+  Assert,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-evaluate-expression-key-property-access */
+export function* EvaluatePropertyAccessWithExpressionKey(baseValue: Value, expression: ParseNode.Expression, strict: boolean): ReferenceEvaluator {
+  // 1. Let propertyNameReference be the result of evaluating expression.
+  const propertyNameReference = Q(yield* Evaluate(expression));
+  // 2. Let propertyNameValue be ? GetValue(propertyNameReference).
+  const propertyNameValue = Q(yield* GetValue(propertyNameReference));
+  // 3. Return the Reference Record { [[Base]]: bv, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: empty }.
+  return new ReferenceRecord({
+    Base: baseValue,
+    ReferencedName: propertyNameValue,
+    Strict: strict ? Value.true : Value.false,
+    ThisValue: undefined,
+  });
+}
+
+/** https://tc39.es/ecma262/#sec-evaluate-identifier-key-property-access */
+export function EvaluatePropertyAccessWithIdentifierKey(baseValue: Value, identifierName: ParseNode.IdentifierName, strict: boolean): PlainCompletion<ReferenceRecord> {
+  // 1. Assert: identifierName is an IdentifierName.
+  Assert(identifierName.type === 'IdentifierName');
+  // 3. Let propertyNameString be StringValue of IdentifierName
+  const propertyNameString = StringValue(identifierName);
+  // 4. Return the Reference Record { [[Base]]: bv, [[ReferencedName]]: propertyNameString, [[Strict]]: strict, [[ThisValue]]: empty }.
+  return new ReferenceRecord({
+    Base: baseValue,
+    ReferencedName: propertyNameString,
+    Strict: strict ? Value.true : Value.false,
+    ThisValue: undefined,
+  });
+}

package/src/runtime-semantics/EvaluateStringOrNumericBinaryExpression.mts

@@ -0,0 +1,19 @@
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { ApplyStringOrNumericBinaryOperator, type BinaryOperator } from './all.mts';
+import { GetValue } from '#self';
+
+/** https://tc39.es/ecma262/#sec-evaluatestringornumericbinaryexpression */
+export function* EvaluateStringOrNumericBinaryExpression(leftOperand: ParseNode.Expression, opText: BinaryOperator, rightOperand: ParseNode.Expression): ValueEvaluator {
+  // 1. Let lref be the result of evaluating leftOperand.
+  const lref = Q(yield* Evaluate(leftOperand));
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(yield* GetValue(lref));
+  // 3. Let rref be the result of evaluating rightOperand.
+  const rref = Q(yield* Evaluate(rightOperand));
+  // 4. Let rval be ? GetValue(rref).
+  const rval = Q(yield* GetValue(rref));
+  // 5. Return ? ApplyStringOrNumericBinaryOperator(lval, opText, rval).
+  return Q(yield* ApplyStringOrNumericBinaryOperator(lval, opText, rval));
+}

package/src/runtime-semantics/ExponentiationExpression.mts

@@ -0,0 +1,11 @@
+import { Q } from '../completion.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { EvaluateStringOrNumericBinaryExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-exp-operator-runtime-semantics-evaluation */
+// ExponentiationExpression : UpdateExpression ** ExponentiationExpression
+export function* Evaluate_ExponentiationExpression({ UpdateExpression, ExponentiationExpression }: ParseNode.ExponentiationExpression): ValueEvaluator {
+  // 1. Return ? EvaluateStringOrNumericBinaryExpression(UpdateExpression, **, ExponentiationExpression).
+  return Q(yield* EvaluateStringOrNumericBinaryExpression(UpdateExpression, '**', ExponentiationExpression));
+}

package/src/runtime-semantics/ExportDeclaration.mts

@@ -0,0 +1,100 @@
+import { Value } from '../value.mts';
+import { Evaluate } from '../evaluator.mts';
+import { BoundNames, IsAnonymousFunctionDefinition } from '../static-semantics/all.mts';
+import { NormalCompletion, Q } from '../completion.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  NamedEvaluation,
+  InitializeBoundName,
+  BindingClassDeclarationEvaluation,
+  DecoratorListEvaluation,
+} from './all.mts';
+import { surroundingAgent } from '#self';
+import {
+  Assert, GetValue, type ECMAScriptFunctionObject, type FunctionDeclaration,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-exports-runtime-semantics-evaluation */
+//   ExportDeclaration :
+//     `export` ExportFromClause FromClause `;`
+//     `export` NamedExports `;`
+//     `export` VariableDeclaration
+//     `export` Declaration
+//     `export` `default` HoistableDeclaration
+//     `export` `default` ClassDeclaration
+//     `export` `default` AssignmentExpression `;`
+export function* Evaluate_ExportDeclaration(ExportDeclaration: ParseNode.ExportDeclaration) {
+  const {
+    FromClause, NamedExports,
+    VariableStatement,
+    Declaration,
+    default: isDefault,
+    HoistableDeclaration,
+    ClassDeclaration,
+    AssignmentExpression,
+    Decorators,
+  } = ExportDeclaration;
+
+  if (FromClause || NamedExports) {
+    // 1. Return NormalCompletion(empty).
+    return NormalCompletion(undefined);
+  }
+  if (VariableStatement) {
+    // 1. Return the result of evaluating VariableStatement.
+    return yield* Evaluate(VariableStatement);
+  }
+  if (Declaration) {
+    if (Decorators) {
+      Assert(Declaration.type === 'ClassDeclaration' && !Declaration.Decorators);
+      const decorators = Q(yield* DecoratorListEvaluation(Decorators));
+      Q(yield* BindingClassDeclarationEvaluation(Declaration, decorators));
+      return undefined;
+    } else {
+      // 1. Return the result of evaluating Declaration.
+      return yield* Evaluate(ExportDeclaration.Declaration!);
+    }
+  }
+  if (!isDefault) {
+    throw OutOfRange.exhaustive(ExportDeclaration);
+  }
+  if (HoistableDeclaration) {
+    // 1. Return the result of evaluating HoistableDeclaration.
+    return yield* Evaluate(HoistableDeclaration);
+  }
+  if (ClassDeclaration) {
+    const decorators = Decorators ? Q(yield* DecoratorListEvaluation(Decorators)) : [];
+    const value = Q(yield* BindingClassDeclarationEvaluation(ClassDeclaration, decorators)) as ECMAScriptFunctionObject;
+    // 2. Let className be the sole element of BoundNames of ClassDeclaration.
+    const className = BoundNames(ClassDeclaration)[0];
+    // If className is "*default*", then
+    if (className.stringValue() === '*default*') {
+      // a. Let env be the running execution context's LexicalEnvironment.
+      const env = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+      // b. Perform ? InitializeBoundName("*default*", value, env).
+      Q(yield* InitializeBoundName(Value('*default*'), value, env));
+    }
+    // 3. Return NormalCompletion(empty).
+    return NormalCompletion(undefined);
+  }
+  if (AssignmentExpression) {
+    let value;
+    // 1. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+    if (IsAnonymousFunctionDefinition(AssignmentExpression)) {
+      // a. Let value be NamedEvaluation of AssignmentExpression with argument "default".
+      value = yield* NamedEvaluation(AssignmentExpression as FunctionDeclaration, Value('default'));
+    } else { // 2. Else,
+      // a. Let rhs be the result of evaluating AssignmentExpression.
+      const rhs = Q(yield* Evaluate(AssignmentExpression));
+      // a. Let value be ? GetValue(rhs).
+      value = Q(yield* GetValue(rhs));
+    }
+    // 3. Let env be the running execution context's LexicalEnvironment.
+    const env = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+    // 4. Perform ? InitializeBoundName("*default*", value, env).
+    Q(yield* InitializeBoundName(Value('*default*'), value as ECMAScriptFunctionObject, env));
+    // 5. Return NormalCompletion(empty).
+    return NormalCompletion(undefined);
+  }
+  throw OutOfRange.exhaustive(ExportDeclaration);
+}

package/src/runtime-semantics/ExpressionStatement.mts

@@ -0,0 +1,14 @@
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { GetValue } from '#self';
+
+/** https://tc39.es/ecma262/#sec-expression-statement-runtime-semantics-evaluation */
+//   ExpressionStatement :
+//     Expression `;`
+export function* Evaluate_ExpressionStatement({ Expression }: ParseNode.ExpressionStatement): ValueEvaluator {
+  // 1. Let exprRef be the result of evaluating Expression.
+  const exprRef = Q(yield* Evaluate(Expression));
+  // 2. Return ? GetValue(exprRef).
+  return Q(yield* GetValue(exprRef));
+}

package/src/runtime-semantics/ForDeclarationBindingInitialization.mts

@@ -0,0 +1,21 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import type { Value } from '../value.mts';
+import type { EnvironmentRecord } from '../execution-context/Environment.mts';
+import { BindingInitialization } from './BindingInitialization.mts';
+import { Q, Throw } from '#self';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-fordeclarationbindinginitialization */
+export function* ForDeclarationBindingInitialization(
+  declaration: ParseNode.ForDeclaration,
+  value: Value,
+  envRecord: EnvironmentRecord,
+): PlainEvaluator {
+  switch (declaration.production) {
+    case 'LetOrConst':
+      return Q(yield* BindingInitialization(declaration.ForBinding, value, envRecord));
+    case 'Using':
+    case 'AwaitUsing':
+      return Throw.SyntaxError('Invalid ForDeclaration binding initialization');
+  }
+}

package/src/runtime-semantics/FunctionDeclaration.mts

@@ -0,0 +1,10 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation */
+// FunctionDeclaration :
+//   function BindingIdentifier ( FormalParameters ) { FunctionBody }
+//   function ( FormalParameters ) { FunctionBody }
+export function Evaluate_FunctionDeclaration(_FunctionDeclaration: ParseNode.FunctionDeclaration) {
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/FunctionDeclarationInstantiation.mts

@@ -0,0 +1,273 @@
+import { Value, type Arguments } from '../value.mts';
+import {
+  BoundNames,
+  IsConstantDeclaration,
+  IsSimpleParameterList,
+  ContainsExpression,
+  VarDeclaredNames,
+  VarScopedDeclarations,
+  LexicallyDeclaredNames,
+  LexicallyScopedDeclarations,
+} from '../static-semantics/all.mts';
+import { Q, X, NormalCompletion } from '../completion.mts';
+import { JSStringSet } from '../utils/container.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import {
+  InstantiateFunctionObject,
+  IteratorBindingInitialization_FormalParameters,
+} from './all.mts';
+import { surroundingAgent, DeclarativeEnvironmentRecord } from '#self';
+import {
+  Assert,
+  CreateListIteratorRecord,
+  CreateMappedArgumentsObject,
+  CreateUnmappedArgumentsObject,
+  type ECMAScriptFunctionObject,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-functiondeclarationinstantiation */
+export function* FunctionDeclarationInstantiation(func: ECMAScriptFunctionObject, argumentsList: Arguments): PlainEvaluator<void> {
+  // 1. Let calleeContext be the running execution context.
+  const calleeContext = surroundingAgent.runningExecutionContext;
+  // 2. Let code be func.[[ECMAScriptCode]].
+  const code = func.ECMAScriptCode!;
+  // 3. Let strict be func.[[Strict]].
+  const strict = func.Strict;
+  // 4. Let formals be func.[[FormalParameters]].
+  const formals = func.FormalParameters;
+  // 5. Let parameterNames be BoundNames of formals.
+  const parameterNames = BoundNames(formals);
+  // 6. If parameterNames has any duplicate entries, let hasDuplicates be true. Otherwise, let hasDuplicates be false.
+  const hasDuplicates = new JSStringSet(parameterNames).size !== parameterNames.length;
+  // 7. Let simpleParameterList be IsSimpleParameterList of formals.
+  const simpleParameterList = IsSimpleParameterList(formals);
+  // 8. Let hasParameterExpressions be ContainsExpression of formals.
+  const hasParameterExpressions = ContainsExpression(formals);
+  // 9. Let varNames be the VarDeclaredNames of code.
+  const varNames = VarDeclaredNames(code);
+  // 10. Let varDeclarations be the VarScopedDeclarations of code.
+  const varDeclarations = VarScopedDeclarations(code);
+  // 11. Let lexicalNames be the LexicallyDeclaredNames of code.
+  const lexicalNames = new JSStringSet(LexicallyDeclaredNames(code));
+  // 12. Let functionNames be a new empty List.
+  const functionNames = new JSStringSet();
+  // 13. Let functionNames be a new empty List.
+  const functionsToInitialize = [];
+  // 14. For each d in varDeclarations, in reverse list order, do
+  for (const d of [...varDeclarations].reverse()) {
+    // a. If d is neither a VariableDeclaration nor a ForBinding nor a BindingIdentifier, then
+    if (d.type !== 'VariableDeclaration'
+        && d.type !== 'ForBinding'
+        && d.type !== 'BindingIdentifier') {
+      // i. Assert: d is either a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration.
+      Assert(d.type === 'FunctionDeclaration'
+             || d.type === 'GeneratorDeclaration'
+             || d.type === 'AsyncFunctionDeclaration'
+             || d.type === 'AsyncGeneratorDeclaration');
+      // ii. Let fn be the sole element of the BoundNames of d.
+      const fn = BoundNames(d)[0];
+      // iii. If fn is not an element of functionNames, then
+      if (!functionNames.has(fn)) {
+        // 1. Insert fn as the first element of functionNames.
+        functionNames.add(fn);
+        // 2. NOTE: If there are multiple function declarations for the same name, the last declaration is used.
+        // 3. Insert d as the first element of functionsToInitialize.
+        functionsToInitialize.unshift(d);
+      }
+    }
+  }
+  // 15. Let argumentsObjectNeeded be true.
+  let argumentsObjectNeeded = true;
+  // If func.[[ThisMode]] is lexical, then
+  if (func.ThisMode === 'lexical') {
+    // a. NOTE: Arrow functions never have an arguments objects.
+    // b. Set argumentsObjectNeeded to false.
+    argumentsObjectNeeded = false;
+  } else if (new JSStringSet(parameterNames).has('arguments')) {
+    // a. Set argumentsObjectNeeded to false.
+    argumentsObjectNeeded = false;
+  } else if (hasParameterExpressions === false) {
+    // a. If "arguments" is an element of functionNames or if "arguments" is an element of lexicalNames, then
+    if (functionNames.has('arguments') || lexicalNames.has('arguments')) {
+      // i. Set argumentsObjectNeeded to false.
+      argumentsObjectNeeded = false;
+    }
+  }
+  let env;
+  // 19. If strict is true or if hasParameterExpressions is false, then
+  if (strict || hasParameterExpressions === false) {
+    // a. NOTE: Only a single lexical environment is needed for the parameters and top-level vars.
+    // b. Let env be the LexicalEnvironment of calleeContext.
+    env = calleeContext.LexicalEnvironment;
+  } else {
+    // a. NOTE: A separate Environment Record is needed to ensure that bindings created by direct eval
+    //    calls in the formal parameter list are outside the environment where parameters are declared.
+    // b. Let calleeEnv be the LexicalEnvironment of calleeContext.
+    const calleeEnv = calleeContext.LexicalEnvironment;
+    // c. Let env be NewDeclarativeEnvironment(calleeEnv).
+    env = new DeclarativeEnvironmentRecord(calleeEnv);
+    // d. Assert: The VariableEnvironment of calleeContext is calleeEnv.
+    Assert(calleeContext.VariableEnvironment === calleeEnv);
+    // e. Set the LexicalEnvironment of calleeContext to env.
+    calleeContext.LexicalEnvironment = env;
+  }
+  // 21. For each String paramName in parameterNames, do
+  for (const paramName of parameterNames) {
+    // a. Let alreadyDeclared be env.HasBinding(paramName).
+    const alreadyDeclared = yield* env.HasBinding(paramName);
+    // b. NOTE: Early errors ensure that duplicate parameter names can only occur in
+    //    non-strict functions that do not have parameter default values or rest parameters.
+    // c. If alreadyDeclared is false, then
+    if (alreadyDeclared === Value.false) {
+      // i. Perform ! env.CreateMutableBinding(paramName, false).
+      X(env.CreateMutableBinding(paramName, Value.false));
+      // ii. If hasDuplicates is true, then
+      if (hasDuplicates === true) {
+        // 1. Perform ! env.InitializeBinding(paramName, undefined).
+        X(env.InitializeBinding(paramName, Value.undefined));
+      }
+    }
+  }
+  // 22. If argumentsObjectNeeded is true, then
+  let parameterBindings: JSStringSet;
+  if (argumentsObjectNeeded === true) {
+    let ao;
+    // a. If strict is true or if simpleParameterList is false, then
+    if (strict || simpleParameterList === false) {
+      // i. Let ao be CreateUnmappedArgumentsObject(argumentsList).
+      ao = CreateUnmappedArgumentsObject(argumentsList);
+    } else {
+      // i. NOTE: mapped argument object is only provided for non-strict functions
+      //    that don't have a rest parameter, any parameter default value initializers,
+      //    or any destructured parameters.
+      // ii. Let ao be CreateMappedArgumentsObject(func, formals, argumentsList, env).
+      ao = CreateMappedArgumentsObject(func, formals, argumentsList, env);
+    }
+    // c. If strict is true, then
+    if (strict) {
+      // i. Perform ! env.CreateImmutableBinding("arguments", false).
+      X(env.CreateImmutableBinding(Value('arguments'), Value.false));
+    } else {
+      // i. Perform ! env.CreateMutableBinding("arguments", false).
+      X(env.CreateMutableBinding(Value('arguments'), Value.false));
+    }
+    // e. Call env.InitializeBinding("arguments", ao).
+    yield* env.InitializeBinding(Value('arguments'), ao);
+    // f. Let parameterBindings be a new List of parameterNames with "arguments" appended.
+    parameterBindings = new JSStringSet(parameterNames);
+    parameterBindings.add('arguments');
+  } else {
+    // a. Let parameterBindings be parameterNames.
+    parameterBindings = new JSStringSet(parameterNames);
+  }
+  // 24. Let iteratorRecord be CreateListIteratorRecord(argumentsList).
+  const iteratorRecord = CreateListIteratorRecord(argumentsList.values());
+  let usedEnv;
+  // 25. If hasDuplicates is true, then
+  if (hasDuplicates) {
+    usedEnv = Value.undefined;
+  } else {
+    usedEnv = env;
+  }
+  // 1. NOTE: The following step cannot return a ReturnCompletion because the only way such a completion can arise in expression position is by use of |YieldExpression|, which is forbidden in parameter lists by Early Error rules in <emu-xref href="#sec-generator-function-definitions-static-semantics-early-errors"></emu-xref> and <emu-xref href="#sec-async-generator-function-definitions-static-semantics-early-errors"></emu-xref>.
+  // Perform ? IteratorBindingInitialization of _formals_ with arguments _iteratorRecord_ and _usedEnv_.
+  Q(yield* IteratorBindingInitialization_FormalParameters(formals, iteratorRecord, usedEnv));
+  let varEnv;
+  // 27. If hasParameterExpressions is false, then
+  if (hasParameterExpressions === false) {
+    // a. NOTE: Only a single lexical environment is needed for the parameters and top-level vars.
+    // b. Let instantiatedVarNames be a copy of the List parameterBindings.
+    const instantiatedVarNames = new JSStringSet(parameterBindings);
+    // c. For each n in varNames, do
+    for (const n of varNames) {
+      // i. If n is not an element of instantiatedVarNames, then
+      if (!instantiatedVarNames.has(n)) {
+        // 1. Append n to instantiatedVarNames.
+        instantiatedVarNames.add(n);
+        // 2. Perform ! env.CreateMutableBinding(n, false).
+        X(env.CreateMutableBinding(n, Value.false));
+        // 3. Call env.InitializeBinding(n, undefined).
+        yield* env.InitializeBinding(n, Value.undefined);
+      }
+    }
+    // d. Let varEnv be env.
+    varEnv = env;
+  } else {
+    // a. NOTE: A separate Environment Record is needed to ensure that closures created by expressions
+    //    in the formal parameter list do not have visibility of declarations in the function body.
+    // b. Let varEnv be NewDeclarativeEnvironment(env).
+    varEnv = new DeclarativeEnvironmentRecord(env);
+    // c. Set the VariableEnvironment of calleeContext to varEnv.
+    calleeContext.VariableEnvironment = varEnv;
+    // d. Let instantiatedVarNames be a new empty List.
+    const instantiatedVarNames = new JSStringSet();
+    // e. For each n in varNames, do
+    for (const n of varNames) {
+      // If n is not an element of instantiatedVarNames, then
+      if (!instantiatedVarNames.has(n)) {
+        // 1. Append n to instantiatedVarNames.
+        instantiatedVarNames.add(n);
+        // 2. Perform ! varEnv.CreateMutableBinding(n, false).
+        X(varEnv.CreateMutableBinding(n, Value.false));
+        let initialValue;
+        // 3. If n is not an element of parameterBindings or if n is an element of functionNames, let initialValue be undefined.
+        if (!parameterBindings.has(n) || functionNames.has(n)) {
+          initialValue = Value.undefined;
+        } else {
+          // a. Let initialValue be ! env.GetBindingValue(n, false).
+          initialValue = X(env.GetBindingValue(n, Value.false));
+        }
+        // 5. Call varEnv.InitializeBinding(n, initialValue).
+        yield* varEnv.InitializeBinding(n, initialValue);
+        // 6. NOTE: vars whose names are the same as a formal parameter, initially have the same value as the corresponding initialized parameter.
+      }
+    }
+  }
+  // 29. NOTE: Annex B.3.3.1 adds additional steps at this point.
+  let lexEnv;
+  // 30. If strict is false, then
+  if (strict === false) {
+    // a. Let lexEnv be NewDeclarativeEnvironment(varEnv).
+    lexEnv = new DeclarativeEnvironmentRecord(varEnv);
+    // b. NOTE: Non-strict functions use a separate lexical Environment Record for top-level lexical declarations
+    //    so that a direct eval can determine whether any var scoped declarations introduced by the eval code
+    //    conflict with pre-existing top-level lexically scoped declarations. This is not needed for strict functions
+    //    because a strict direct eval always places all declarations into a new Environment Record.
+  } else {
+    // a. Else, let lexEnv be varEnv.
+    lexEnv = varEnv;
+  }
+  // 32. Set the LexicalEnvironment of calleeContext to lexEnv.
+  calleeContext.LexicalEnvironment = lexEnv;
+  // 33. Let lexDeclarations be the LexicallyScopedDeclarations of code.
+  const lexDeclarations = LexicallyScopedDeclarations(code);
+  // 34. For each element d in lexDeclarations, do
+  for (const d of lexDeclarations) {
+    // a. NOTE: A lexically declared name cannot be the same as a function/generator declaration, formal
+    //    parameter, or a var name. Lexically declared names are only instantiated here but not initialized.
+    // b. For each element dn of the BoundNames of d, do
+    for (const dn of BoundNames(d)) {
+      // i. If IsConstantDeclaration of d is true, then
+      if (IsConstantDeclaration(d)) {
+        // 1. Perform ! lexEnv.CreateImmutableBinding(dn, true).
+        X(lexEnv.CreateImmutableBinding(dn, Value.true));
+      } else {
+        // 1. Perform ! lexEnv.CreateMutableBinding(dn, false).
+        X(lexEnv.CreateMutableBinding(dn, Value.false));
+      }
+    }
+  }
+  // 35. Let privateEnv be the PrivateEnvironment of calleeContext.
+  const privateEnv = calleeContext.PrivateEnvironment;
+  // 36. For each Parse Node f in functionsToInitialize, do
+  for (const f of functionsToInitialize) {
+    // a. Let fn be the sole element of the BoundNames of f.
+    const fn = BoundNames(f)[0];
+    // b. Let fo be InstantiateFunctionObject of f with argument lexEnv and privateEnv.
+    const fo = InstantiateFunctionObject(f, lexEnv, privateEnv);
+    // c. Perform ! varEnv.SetMutableBinding(fn, fo, false).
+    X(varEnv.SetMutableBinding(fn, fo, Value.false));
+  }
+  // 37. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/FunctionExpression.mts

@@ -0,0 +1,10 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { InstantiateOrdinaryFunctionExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation */
+//   FunctionExpression :
+//     `function` `(` FormalParameters `)` `{` FunctionBody `}`
+//     `function` BindingIdentifier `(` FormalParameters `)` `{` FunctionBody `}`
+export function Evaluate_FunctionExpression(FunctionExpression: ParseNode.FunctionExpression) {
+  return InstantiateOrdinaryFunctionExpression(FunctionExpression);
+}

package/src/runtime-semantics/FunctionStatementList.mts

@@ -0,0 +1,17 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { EnsureCompletion } from '../completion.mts';
+import { DisposeResources } from '../abstract-ops/disposable-operations.mts';
+import { Evaluate_StatementList } from './all.mts';
+import { Assert, DeclarativeEnvironmentRecord, Q, surroundingAgent, type StatementEvaluator } from '#self';
+
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation */
+//   FunctionStatementList : [empty]
+//
+// (implicit)
+//   FunctionStatementList : StatementList
+export function* Evaluate_FunctionStatementList(FunctionStatementList: ParseNode.FunctionStatementList): StatementEvaluator {
+  const result = EnsureCompletion(yield* Evaluate_StatementList(FunctionStatementList));
+  const env = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  Assert(env instanceof DeclarativeEnvironmentRecord);
+  return Q(yield* DisposeResources(env.DisposableResourceStack, result));
+}

package/src/runtime-semantics/GeneratorExpression.mts

@@ -0,0 +1,11 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { InstantiateGeneratorFunctionExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluation */
+//   GeneratorExpression :
+//     `function` `*` `(` FormalParameters `)` `{` GeneratorBody `}`
+//     `function` `*` BindingIdentifier `(` FormalParameters `)` `{` GeneratorBody `}`
+export function Evaluate_GeneratorExpression(GeneratorExpression: ParseNode.GeneratorExpression) {
+  // 1. Return InstantiateGeneratorFunctionExpression of GeneratorExpression.
+  return InstantiateGeneratorFunctionExpression(GeneratorExpression);
+}

package/src/runtime-semantics/GetSubstitution.mts

@@ -0,0 +1,90 @@
+import {
+  ObjectValue, UndefinedValue, JSStringValue, Value,
+} from '../value.mts';
+import { Q } from '../completion.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import {
+  Assert,
+  Get,
+  ToString,
+  Throw,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-getsubstitution */
+export function* GetSubstitution(matched: JSStringValue, str: JSStringValue, position: number, captures: readonly (JSStringValue | UndefinedValue)[], namedCaptures: UndefinedValue | ObjectValue, replacementTemplate: JSStringValue): ValueEvaluator<JSStringValue> {
+  const stringLength = str.stringValue().length;
+  Assert(position <= stringLength);
+  const result: string[] = [];
+  let templateRemainder = replacementTemplate.stringValue();
+  let ref: string;
+  let refReplacement: string;
+  while (templateRemainder.length) {
+    if (templateRemainder.startsWith('$$')) {
+      ref = '$$';
+      refReplacement = '$';
+    } else if (templateRemainder.startsWith('$`')) {
+      ref = '$`';
+      refReplacement = str.stringValue().slice(0, position);
+    } else if (templateRemainder.startsWith('$&')) {
+      ref = '$&';
+      refReplacement = matched.stringValue();
+    } else if (templateRemainder.startsWith("$'")) {
+      ref = "$'";
+      const matchLength = matched.stringValue().length;
+      const tailPos = position + matchLength;
+      refReplacement = str.stringValue().slice(Math.min(tailPos, stringLength));
+    } else if (templateRemainder.match(/^\$\d+/)) {
+      let digitCount = templateRemainder.match(/^\$\d\d/) ? 2 : 1;
+      let digits = templateRemainder.slice(1, 1 + digitCount);
+      let index = parseInt(digits, 10);
+      Assert(index >= 0 && index <= 99);
+      const captureLen = captures.length;
+      if (index > captureLen && digitCount === 2) {
+        digitCount = 1;
+        digits = digits[0];
+        index = parseInt(digits, 10);
+      }
+      ref = templateRemainder.slice(0, 1 + digitCount);
+      if (index >= 1 && index <= captureLen) {
+        const capture = captures[index - 1];
+        if (capture instanceof UndefinedValue) {
+          refReplacement = '';
+        } else {
+          refReplacement = capture.stringValue();
+        }
+      } else {
+        refReplacement = ref;
+      }
+    } else if (templateRemainder.startsWith('$<')) {
+      const gtPos = templateRemainder.indexOf('>', 0);
+      if (gtPos === -1 || namedCaptures instanceof UndefinedValue) {
+        ref = '$<';
+        refReplacement = ref;
+      } else {
+        ref = templateRemainder.slice(0, gtPos + 1);
+        const groupName = templateRemainder.slice(2, gtPos);
+        Assert(namedCaptures instanceof ObjectValue);
+        const capture = Q(yield* Get(namedCaptures, Value(groupName)));
+        if (capture instanceof UndefinedValue) {
+          refReplacement = '';
+        } else {
+          refReplacement = (Q(yield* ToString(capture))).stringValue();
+        }
+      }
+    } else {
+      ref = templateRemainder[0];
+      refReplacement = ref;
+    }
+    const refLength = ref.length;
+    templateRemainder = templateRemainder.slice(refLength);
+    result.push(refReplacement);
+  }
+  let result_str;
+  try {
+    result_str = result.join('');
+  } catch (e) {
+    // test262/test/staging/sm/String/replace-math.js
+    return Throw.RangeError('String is too long');
+  }
+  return Value(result_str);
+}