@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/runtime-semantics/FunctionDeclarationInstantiation.mts

@@ -0,0 +1,272 @@
+import { surroundingAgent } from '../engine.mts';
+import { Value, type Arguments } from '../value.mts';
+import {
+  Assert,
+  CreateListIteratorRecord,
+  CreateMappedArgumentsObject,
+  CreateUnmappedArgumentsObject,
+  type ECMAScriptFunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  BoundNames,
+  IsConstantDeclaration,
+  IsSimpleParameterList,
+  ContainsExpression,
+  VarDeclaredNames,
+  VarScopedDeclarations,
+  LexicallyDeclaredNames,
+  LexicallyScopedDeclarations,
+} from '../static-semantics/all.mts';
+import { DeclarativeEnvironmentRecord } from '../environment.mts';
+import { Q, X, NormalCompletion } from '../completion.mts';
+import { JSStringSet } from '../helpers.mts';
+import type { StatementEvaluator } from '../evaluator.mts';
+import {
+  InstantiateFunctionObject,
+  IteratorBindingInitialization_FormalParameters,
+} from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-functiondeclarationinstantiation */
+export function* FunctionDeclarationInstantiation(func: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator {
+  // 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 = 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).
+    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);
+  // 25. If hasDuplicates is true, then
+  if (hasDuplicates) {
+    // a. Perform ? IteratorBindingInitialization for formals with iteratorRecord and undefined as arguments.
+    Q(yield* IteratorBindingInitialization_FormalParameters(formals, iteratorRecord, Value.undefined));
+  } else {
+    // a. Perform ? IteratorBindingInitialization for formals with iteratorRecord and env as arguments.
+    Q(yield* IteratorBindingInitialization_FormalParameters(formals, iteratorRecord, env));
+  }
+  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).
+        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).
+        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,11 @@
+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) {
+  // 1. Return InstantiateOrdinaryFunctionExpression of FunctionExpression.
+  return InstantiateOrdinaryFunctionExpression(FunctionExpression);
+}

package/src/runtime-semantics/FunctionStatementList.mts

@@ -0,0 +1,11 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { Evaluate_StatementList } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation */
+//   FunctionStatementList : [empty]
+//
+// (implicit)
+//   FunctionStatementList : StatementList
+export function Evaluate_FunctionStatementList(FunctionStatementList: ParseNode.FunctionStatementList) {
+  return Evaluate_StatementList(FunctionStatementList);
+}

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,119 @@
+import {
+  Assert,
+  Get,
+  ToString,
+  isNonNegativeInteger,
+} from '../abstract-ops/all.mts';
+import {
+  ObjectValue, UndefinedValue, JSStringValue, Value,
+} from '../value.mts';
+import { Q, type ExpressionCompletion } from '../completion.mts';
+
+/** https://tc39.es/ecma262/#sec-getsubstitution */
+export function GetSubstitution(matched: JSStringValue, str: JSStringValue, position: number, captures: readonly (JSStringValue | UndefinedValue)[], namedCaptures: UndefinedValue | ObjectValue, replacement: JSStringValue): ExpressionCompletion<JSStringValue> {
+  // 1. Assert: Type(matched) is String.
+  Assert(matched instanceof JSStringValue);
+  // 2. Let matchLength be the number of code units in matched.
+  const matchLength = matched.stringValue().length;
+  // 3. Assert: Type(str) is String.
+  Assert(str instanceof JSStringValue);
+  // 4. Let stringLength be the number of code units in str.
+  const stringLength = str.stringValue().length;
+  // 5. Assert: position is a non-negative integer.
+  Assert(isNonNegativeInteger(position));
+  // 6. Assert: position ≤ stringLength.
+  Assert(position <= stringLength);
+  // 7. Assert: captures is a possibly empty List of Strings.
+  Assert(Array.isArray(captures) && captures.every((value) => value instanceof JSStringValue || value instanceof UndefinedValue));
+  // 8. Assert: Type(replacement) is String.
+  Assert(replacement instanceof JSStringValue);
+  // 9. Let tailPos be position + matchLength.
+  const tailPos = position + matchLength;
+  // 10. Let m be the number of elements in captures.
+  const m = captures.length;
+  // 11. Let result be the String value derived from replacement by copying code unit elements from replacement
+  //     to result while performing replacements as specified in Table 52. These $ replacements are done left-to-right,
+  //     and, once such a replacement is performed, the new replacement text is not subject to further replacements.
+  const replacementStr = replacement.stringValue();
+  let result = '';
+  let i = 0;
+  while (i < replacementStr.length) {
+    const currentChar = replacementStr[i];
+    if (currentChar === '$' && i < replacementStr.length - 1) {
+      const nextChar = replacementStr[i + 1];
+      if (nextChar === '$') {
+        result += '$';
+        i += 2;
+      } else if (nextChar === '&') {
+        result += matched.stringValue();
+        i += 2;
+      } else if (nextChar === '`') {
+        if (position === 0) {
+          // Replacement is the empty String
+        } else {
+          result += str.stringValue().substring(0, position);
+        }
+        i += 2;
+      } else if (nextChar === '\'') {
+        if (tailPos >= stringLength) {
+          // Replacement is the empty String
+        } else {
+          result += str.stringValue().substring(tailPos);
+        }
+        i += 2;
+      } else if ('123456789'.includes(nextChar) && (i === replacementStr.length - 2 || !'0123456789'.includes(replacementStr[i + 2]))) {
+        const n = Number(nextChar);
+        if (n <= m) {
+          const capture = captures[n - 1];
+          if (!(capture instanceof UndefinedValue)) {
+            result += capture.stringValue();
+          }
+        } else {
+          result += `$${nextChar}`;
+        }
+        i += 2;
+      } else if (i < replacementStr.length - 2 && '0123456789'.includes(nextChar) && '0123456789'.includes(replacementStr[i + 2])) {
+        const nextNextChar = replacementStr[i + 2];
+        const n = Number(nextChar + nextNextChar);
+        if (n !== 0 && n <= m) {
+          const capture = captures[n - 1];
+          if (!(capture instanceof UndefinedValue)) {
+            result += capture.stringValue();
+          }
+        } else {
+          result += `$${nextChar}${nextNextChar}`;
+        }
+        i += 3;
+      } else if (nextChar === '<') {
+        if (namedCaptures === Value.undefined) {
+          result += '$<';
+          i += 2;
+        } else {
+          Assert(namedCaptures instanceof ObjectValue);
+          const nextSign = replacementStr.indexOf('>', i);
+          if (nextSign === -1) {
+            result += '$<';
+            i += 2;
+          } else {
+            const groupName = Value(replacementStr.substring(i + 2, nextSign));
+            const capture = Q(Get(namedCaptures, groupName));
+            if (capture === Value.undefined) {
+              // Replace the text with the empty string
+            } else {
+              result += Q(ToString(capture)).stringValue();
+            }
+            i = nextSign + 1;
+          }
+        }
+      } else {
+        result += '$';
+        i += 1;
+      }
+    } else {
+      result += currentChar;
+      i += 1;
+    }
+  }
+  // 12. Return result.
+  return Value(result);
+}

package/src/runtime-semantics/GlobalDeclarationInstantiation.mts

@@ -0,0 +1,146 @@
+import { surroundingAgent } from '../engine.mts';
+import { GlobalEnvironmentRecord } from '../environment.mts';
+import { Assert } from '../abstract-ops/all.mts';
+import {
+  BoundNames,
+  IsConstantDeclaration,
+  LexicallyDeclaredNames,
+  LexicallyScopedDeclarations,
+  VarDeclaredNames,
+  VarScopedDeclarations,
+} from '../static-semantics/all.mts';
+import { Value } from '../value.mts';
+import { Q, NormalCompletion } from '../completion.mts';
+import { JSStringSet } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { InstantiateFunctionObject } from './all.mts';
+
+export function GlobalDeclarationInstantiation(script: ParseNode.Script, env: GlobalEnvironmentRecord) {
+  // 2. Let lexNames be the LexicallyDeclaredNames of script.
+  const lexNames = LexicallyDeclaredNames(script);
+  // 3. Let varNames be the VarDeclaredNames of script.
+  const varNames = VarDeclaredNames(script);
+  // 4. For each name in lexNames, do
+  for (const name of lexNames) {
+    // 1. If env.HasVarDeclaration(name) is true, throw a SyntaxError exception.
+    if (env.HasVarDeclaration(name) === Value.true) {
+      return surroundingAgent.Throw('SyntaxError', 'AlreadyDeclared', name);
+    }
+    // 1. If env.HasLexicalDeclaration(name) is true, throw a SyntaxError exception.
+    if (env.HasLexicalDeclaration(name) === Value.true) {
+      return surroundingAgent.Throw('SyntaxError', 'AlreadyDeclared', name);
+    }
+    // 1. Let hasRestrictedGlobal be ? env.HasRestrictedGlobalProperty(name).
+    const hasRestrictedGlobal = Q(env.HasRestrictedGlobalProperty(name));
+    // 1. If hasRestrictedGlobal is true, throw a SyntaxError exception.
+    if (hasRestrictedGlobal === Value.true) {
+      return surroundingAgent.Throw('SyntaxError', 'AlreadyDeclared', name);
+    }
+  }
+  // 5. For each name in varNames, do
+  for (const name of varNames) {
+    // 1. If env.HasLexicalDeclaration(name) is true, throw a SyntaxError exception.
+    if (env.HasLexicalDeclaration(name) === Value.true) {
+      return surroundingAgent.Throw('SyntaxError', 'AlreadyDeclared', name);
+    }
+  }
+  // 6. Let varDeclarations be the VarScopedDeclarations of script.
+  const varDeclarations = VarScopedDeclarations(script);
+  // 7. Let functionsToInitialize be a new empty List.
+  const functionsToInitialize = [];
+  // 8. Let declaredFunctionNames be a new empty List.
+  const declaredFunctionNames = new JSStringSet();
+  // 9. 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. NOTE: If there are multiple function declarations for the same name, the last declaration is used.
+      // iii. Let fn be the sole element of the BoundNames of d.
+      const fn = BoundNames(d)[0];
+      // iv. If fn is not an element of declaredFunctionNames, then
+      if (!declaredFunctionNames.has(fn)) {
+        // 1. Let fnDefinable be ? env.CanDeclareGlobalFunction(fn).
+        const fnDefinable = Q(env.CanDeclareGlobalFunction(fn));
+        // 2. If fnDefinable is false, throw a TypeError exception.
+        if (fnDefinable === Value.false) {
+          return surroundingAgent.Throw('TypeError', 'AlreadyDeclared', fn);
+        }
+        // 3. Append fn to declaredFunctionNames.
+        declaredFunctionNames.add(fn);
+        // 4. Insert d as the first element of functionsToInitialize.
+        functionsToInitialize.unshift(d);
+      }
+    }
+  }
+  // 10. Let declaredVarNames be a new empty List.
+  const declaredVarNames = new JSStringSet();
+  // 11. For each d in varDeclarations, do
+  for (const d of varDeclarations) {
+    // a. If d is a VariableDeclaration, a ForBinding, or a BindingIdentifier, then
+    if (d.type === 'VariableDeclaration'
+        || d.type === 'ForBinding'
+        || d.type === 'BindingIdentifier') {
+      // i. For each String vn in the BoundNames of d, do
+      for (const vn of BoundNames(d)) {
+        // 1. If vn is not an element of declaredFunctionNames, then
+        if (!declaredFunctionNames.has(vn)) {
+          // a. Let vnDefinable be ? env.CanDeclareGlobalVar(vn).
+          const vnDefinable = Q(env.CanDeclareGlobalVar(vn));
+          // b. If vnDefinable is false, throw a TypeError exception.
+          if (vnDefinable === Value.false) {
+            return surroundingAgent.Throw('TypeError', 'AlreadyDeclared', vn);
+          }
+          // c. If vn is not an element of declaredVarNames, then
+          if (!declaredVarNames.has(vn)) {
+            // i. Append vn to declaredVarNames.
+            declaredVarNames.add(vn);
+          }
+        }
+      }
+    }
+  }
+  // 12. NOTE: No abnormal terminations occur after this algorithm step if the global object is an ordinary object. However, if the global object is a Proxy exotic object it may exhibit behaviours that cause abnormal terminations in some of the following steps.
+  // 13. NOTE: Annex B.3.3.2 adds additional steps at this point.
+  // 14. Let lexDeclarations be the LexicallyScopedDeclarations of script.
+  const lexDeclarations = LexicallyScopedDeclarations(script);
+  // 15. Let privateEnv be null.
+  const privateEnv = Value.null;
+  // 16. For each element d in lexDeclarations, do
+  for (const d of lexDeclarations) {
+    // a. NOTE: 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)) {
+      // 1. If IsConstantDeclaration of d is true, then
+      if (IsConstantDeclaration(d)) {
+        // 1. Perform ? env.CreateImmutableBinding(dn, true).
+        Q(env.CreateImmutableBinding(dn, Value.true));
+      } else { // 1. Else,
+        // 1. Perform ? env.CreateMutableBinding(dn, false).
+        Q(env.CreateMutableBinding(dn, Value.false));
+      }
+    }
+  }
+  // 17. 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 env and privateEnv.
+    const fo = InstantiateFunctionObject(f, env, privateEnv);
+    // c. Perform ? env.CreateGlobalFunctionBinding(fn, fo, false).
+    Q(env.CreateGlobalFunctionBinding(fn, fo, Value.false));
+  }
+  // 18. For each String vn in declaredVarNames, in list order, do
+  for (const vn of declaredVarNames) {
+    // a. Perform ? env.CreateGlobalVarBinding(vn, false).
+    Q(env.CreateGlobalVarBinding(vn, Value.false));
+  }
+  // 19. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/HoistableDeclaration.mts

@@ -0,0 +1,12 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation */
+//   HoistableDeclaration :
+//     GeneratorDeclaration
+//     AsyncFunctionDeclaration
+//     AsyncGeneratorDeclaration
+export function Evaluate_HoistableDeclaration(_HoistableDeclaration: ParseNode.HoistableDeclaration) {
+  // 1. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/IdentifierReference.mts

@@ -0,0 +1,15 @@
+import { ResolveBinding } from '../abstract-ops/all.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { type PlainCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ReferenceRecord } from '../value.mts';
+
+/** https://tc39.es/ecma262/#sec-identifiers-runtime-semantics-evaluation */
+// IdentifierReference :
+//   Identifier
+//   `yield`
+//   `await`
+export function Evaluate_IdentifierReference(IdentifierReference: ParseNode.IdentifierReference): PlainCompletion<ReferenceRecord> {
+  // 1. Return ? ResolveBinding(StringValue of Identifier).
+  return ResolveBinding(StringValue(IdentifierReference), undefined, IdentifierReference.strict);
+}

package/src/runtime-semantics/IfStatement.mts

@@ -0,0 +1,49 @@
+import { Evaluate } from '../evaluator.mts';
+import {
+  GetValue,
+  ToBoolean,
+} from '../abstract-ops/all.mts';
+import {
+  Completion,
+  EnsureCompletion,
+  NormalCompletion,
+  Q,
+  UpdateEmpty,
+} from '../completion.mts';
+import { Value } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-if-statement-runtime-semantics-evaluation */
+// IfStatement :
+//   `if` `(` Expression `)` Statement `else` Statement
+//   `if` `(` Expression `)` Statement
+export function* Evaluate_IfStatement({ Expression, Statement_a, Statement_b }: ParseNode.IfStatement) {
+  // 1. Let exprRef be the result of evaluating Expression.
+  const exprRef = yield* Evaluate(Expression);
+  // 2. Let exprValue be ! ToBoolean(? GetValue(exprRef)).
+  const exprValue = ToBoolean(Q(GetValue(exprRef)));
+  if (Statement_b) {
+    let stmtCompletion;
+    // 3. If exprValue is true, then
+    if (exprValue === Value.true) {
+      // a. Let stmtCompletion be the result of evaluating the first Statement.
+      stmtCompletion = yield* Evaluate(Statement_a);
+    } else { // 4. Else,
+      // a. Let stmtCompletion be the result of evaluating the second Statement.
+      stmtCompletion = yield* Evaluate(Statement_b);
+    }
+    // 5. Return Completion(UpdateEmpty(stmtCompletion, undefined)).
+    return Completion(UpdateEmpty(EnsureCompletion(stmtCompletion), Value.undefined));
+  } else {
+    // 3. If exprValue is false, then
+    if (exprValue === Value.false) {
+      // a. Return NormalCompletion(undefined).
+      return NormalCompletion(Value.undefined);
+    } else { // 4. Else,
+      // a. Let stmtCompletion be the result of evaluating Statement.
+      const stmtCompletion = yield* Evaluate(Statement_a);
+      // b. Return Completion(UpdateEmpty(stmtCompletion, undefined)).
+      return Completion(UpdateEmpty(EnsureCompletion(stmtCompletion), Value.undefined));
+    }
+  }
+}