@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/ArrayLiteral.mts

@@ -0,0 +1,99 @@
+import { ObjectValue, Value } from '../value.mts';
+import {
+  Evaluate, type PlainEvaluator,
+  type ValueEvaluator,
+} from '../evaluator.mts';
+import {
+  Q, X,
+} from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Set,
+  ArrayCreate,
+  GetValue,
+  GetIterator,
+  ToString,
+  CreateDataPropertyOrThrow,
+  F,
+  IteratorStepValue,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-arrayaccumulation */
+//  Elision :
+//    `,`
+//    Elision `,`
+//  ElementList :
+//    Elision? AssignmentExpression
+//    Elision? SpreadElement
+//    ElementList `,` Elision? AssignmentExpression
+//    ElementList : ElementList `,` Elision SpreadElement
+//  SpreadElement :
+//    `...` AssignmentExpression
+function* ArrayAccumulation(ElementList: ParseNode.ElementList, array: ObjectValue, nextIndex: number): PlainEvaluator<number> {
+  let postIndex = nextIndex;
+  for (const element of ElementList) {
+    switch (element.type) {
+      case 'Elision':
+        postIndex += 1;
+        Q(yield* Set(array, Value('length'), F(postIndex), Value.true));
+        break;
+      case 'SpreadElement':
+        postIndex = Q(yield* ArrayAccumulation_SpreadElement(element, array, postIndex));
+        break;
+      default:
+        postIndex = Q(yield* ArrayAccumulation_AssignmentExpression(element, array, postIndex));
+        break;
+    }
+  }
+  return postIndex;
+}
+
+// SpreadElement : `...` AssignmentExpression
+function* ArrayAccumulation_SpreadElement({ AssignmentExpression }: ParseNode.SpreadElement, array: ObjectValue, nextIndex: number): PlainEvaluator<number> {
+  // 1. Let spreadRef be the result of evaluating AssignmentExpression.
+  const spreadRef = Q(yield* Evaluate(AssignmentExpression));
+  // 2. Let spreadObj be ? GetValue(spreadRef).
+  const spreadObj = Q(yield* GetValue(spreadRef));
+  // 3. Let iteratorRecord be ? GetIterator(spreadObj).
+  const iteratorRecord = Q(yield* GetIterator(spreadObj, 'sync'));
+  // 4. Repeat,
+  while (true) {
+    // a. Let next be ? IteratorStep(iteratorRecord).
+    const next = Q(yield* IteratorStepValue(iteratorRecord));
+    // b. If next is done, return nextIndex.
+    if (next === 'done') {
+      return nextIndex;
+    }
+    // d. Perform ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), next).
+    X(CreateDataPropertyOrThrow(array, X(ToString(F(nextIndex))), next));
+    // e. Set nextIndex to nextIndex + 1.
+    nextIndex += 1;
+  }
+}
+
+
+function* ArrayAccumulation_AssignmentExpression(AssignmentExpression: ParseNode.AssignmentExpressionOrHigher, array: ObjectValue, nextIndex: number): PlainEvaluator<number> {
+  // 2. Let initResult be the result of evaluating AssignmentExpression.
+  const initResult = Q(yield* Evaluate(AssignmentExpression));
+  // 3. Let initValue be ? GetValue(initResult).
+  const initValue = Q(yield* GetValue(initResult));
+  // 4. Let created be ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), initValue).
+  X(CreateDataPropertyOrThrow(array, X(ToString(F(nextIndex))), initValue));
+  // 5. Return nextIndex + 1.
+  return nextIndex + 1;
+}
+
+/** https://tc39.es/ecma262/#sec-array-initializer-runtime-semantics-evaluation */
+//  ArrayLiteral :
+//    `[` Elision `]`
+//    `[` ElementList `]`
+//    `[` ElementList `,` Elision `]`
+export function* Evaluate_ArrayLiteral({ ElementList }: ParseNode.ArrayLiteral): ValueEvaluator {
+  // 1. Let array be ! ArrayCreate(0).
+  const array = X(ArrayCreate(0));
+  // 2. Let len be the result of performing ArrayAccumulation for ElementList with arguments array and 0.
+  const len = yield* ArrayAccumulation(ElementList, array, 0);
+  Q(len);
+  // 4. Return array.
+  return array;
+}

package/src/runtime-semantics/ArrowFunction.mts

@@ -0,0 +1,8 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { InstantiateArrowFunctionExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-arrow-function-definitions-runtime-semantics-evaluation */
+export function Evaluate_ArrowFunction(ArrowFunction: ParseNode.ArrowFunction) {
+  // 1. Return InstantiateArrowFunctionExpression of ArrowFunction.
+  return InstantiateArrowFunctionExpression(ArrowFunction);
+}

package/src/runtime-semantics/AssignmentExpression.mts

@@ -0,0 +1,284 @@
+import { JSStringValue, ReferenceRecord, Value } from '../value.mts';
+import { Q, X } from '../completion.mts';
+import {
+  IsAnonymousFunctionDefinition,
+  IsIdentifierRef,
+  type DestructuringParseNode,
+  type FunctionDeclaration,
+} from '../static-semantics/all.mts';
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  NamedEvaluation,
+  ApplyStringOrNumericBinaryOperator,
+  DestructuringAssignmentEvaluation,
+} from './all.mts';
+import {
+  GetValue,
+  PutValue,
+  ToBoolean,
+} from '#self';
+
+
+/** https://tc39.es/ecma262/#sec-destructuring-assignment */
+export function refineLeftHandSideExpression(node: ParseNode.ArrayLiteral | ParseNode.ObjectLiteral | ParseNode.PropertyDefinition | ParseNode.MemberExpression | ParseNode.CoverInitializedName | ParseNode.AssignmentExpression | ParseNode.Elision | ParseNode.IdentifierReference | ParseNode.ElementListElement | DestructuringParseNode | ParseNode.Expression, type?: 'array' | 'object'): ParseNode.AssignmentPattern {
+  switch (node.type) {
+    case 'ArrayLiteral': {
+      const refinement: ParseNode.ArrayAssignmentPattern = {
+        type: 'ArrayAssignmentPattern',
+        AssignmentElementList: [],
+        AssignmentRestElement: undefined,
+      };
+      node.ElementList.forEach((n) => {
+        switch (n.type) {
+          case 'SpreadElement':
+            refinement.AssignmentRestElement = {
+              ...n,
+              type: 'AssignmentRestElement',
+              AssignmentExpression: n.AssignmentExpression,
+            };
+            break;
+          case 'ArrayLiteral':
+          case 'ObjectLiteral':
+            refinement.AssignmentElementList.push({
+              type: 'AssignmentElement',
+              DestructuringAssignmentTarget: n,
+              Initializer: null,
+            });
+            break;
+          default:
+            refinement.AssignmentElementList.push(refineLeftHandSideExpression(n, 'array'));
+            break;
+        }
+      });
+      return refinement;
+    }
+    case 'ObjectLiteral': {
+      const refined: ParseNode.ObjectAssignmentPattern = {
+        type: 'ObjectAssignmentPattern',
+        AssignmentPropertyList: [],
+        AssignmentRestProperty: undefined,
+      };
+      node.PropertyDefinitionList.forEach((p) => {
+        if ((p as ParseNode.PropertyDefinition).PropertyName === null && (p as ParseNode.PropertyDefinition).AssignmentExpression) {
+          refined.AssignmentRestProperty = {
+            type: 'AssignmentRestProperty',
+            DestructuringAssignmentTarget: (p as ParseNode.PropertyDefinition).AssignmentExpression,
+          };
+        } else {
+          refined.AssignmentPropertyList.push(refineLeftHandSideExpression(p as ParseNode.PropertyDefinition, 'object'));
+        }
+      });
+      return refined;
+    }
+    case 'PropertyDefinition':
+      return {
+        type: 'AssignmentProperty',
+        PropertyName: node.PropertyName,
+        AssignmentElement: node.AssignmentExpression.type === 'AssignmentExpression'
+          ? {
+            type: 'AssignmentElement',
+            DestructuringAssignmentTarget: node.AssignmentExpression.LeftHandSideExpression,
+            Initializer: node.AssignmentExpression.AssignmentExpression,
+          }
+          : {
+            type: 'AssignmentElement',
+            DestructuringAssignmentTarget: node.AssignmentExpression,
+            Initializer: undefined,
+          },
+      };
+    case 'IdentifierReference':
+      if (type === 'array') {
+        return {
+          type: 'AssignmentElement',
+          DestructuringAssignmentTarget: node,
+          Initializer: undefined,
+        };
+      } else {
+        return {
+          type: 'AssignmentProperty',
+          IdentifierReference: node,
+          Initializer: undefined,
+        };
+      }
+    case 'MemberExpression':
+    case 'SuperProperty':
+      return {
+        type: 'AssignmentElement',
+        DestructuringAssignmentTarget: node,
+        Initializer: undefined,
+      };
+    case 'CoverInitializedName':
+      return {
+        type: 'AssignmentProperty',
+        IdentifierReference: node.IdentifierReference,
+        Initializer: node.Initializer,
+      };
+    case 'AssignmentExpression':
+      return {
+        type: 'AssignmentElement',
+        DestructuringAssignmentTarget: node.LeftHandSideExpression,
+        Initializer: node.AssignmentExpression,
+      };
+    case 'Elision':
+      return node;
+    case 'ParenthesizedExpression':
+      return refineLeftHandSideExpression(node.Expression, type);
+    default:
+      throw OutOfRange.nonExhaustive(node.type);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-assignment-operators-runtime-semantics-evaluation */
+//   AssignmentExpression :
+//     LeftHandSideExpression `=` AssignmentExpression
+//     LeftHandSideExpression AssignmentOperator AssignmentExpression
+//     LeftHandSideExpression `&&=` AssignmentExpression
+//     LeftHandSideExpression `||=` AssignmentExpression
+//     LeftHandSideExpression `??=` AssignmentExpression
+export function* Evaluate_AssignmentExpression({
+  LeftHandSideExpression, AssignmentOperator, AssignmentExpression,
+}: ParseNode.AssignmentExpression): ValueEvaluator {
+  if (AssignmentOperator === '=') {
+    // 1. If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, then
+    if (LeftHandSideExpression.type !== 'ObjectLiteral' && LeftHandSideExpression.type !== 'ArrayLiteral') {
+      // a. Let lref be the result of evaluating LeftHandSideExpression.
+      const lref = Q(yield* Evaluate(LeftHandSideExpression));
+      Q(lref);
+      // c. If IsAnonymousFunctionDefinition(AssignmentExpression) and IsIdentifierRef of LeftHandSideExpression are both true, then
+      let rval;
+      if (IsAnonymousFunctionDefinition(AssignmentExpression) && IsIdentifierRef(LeftHandSideExpression)) {
+        // i. Let rval be NamedEvaluation of AssignmentExpression with argument GetReferencedName(lref).
+        rval = Q(yield* NamedEvaluation(AssignmentExpression as FunctionDeclaration, (lref as ReferenceRecord).ReferencedName as JSStringValue));
+      } else { // d. Else,
+        // i. Let rref be the result of evaluating AssignmentExpression.
+        const rref = Q(yield* Evaluate(AssignmentExpression));
+        // ii. Let rval be ? GetValue(rref).
+        rval = Q(yield* GetValue(rref));
+      }
+      // e. Perform ? PutValue(lref, rval).
+      Q(yield* PutValue(lref, rval));
+      // f. Return rval.
+      return rval;
+    }
+    // 2. Let assignmentPattern be the AssignmentPattern that is covered by LeftHandSideExpression.
+    const assignmentPattern = refineLeftHandSideExpression(LeftHandSideExpression);
+    // 3. Let rref be the result of evaluating AssignmentExpression.
+    const rref = Q(yield* Evaluate(AssignmentExpression));
+    // 3. Let rval be ? GetValue(rref).
+    const rval = Q(yield* GetValue(rref));
+    // 4. Perform ? DestructuringAssignmentEvaluation of assignmentPattern using rval as the argument.
+    Q(yield* DestructuringAssignmentEvaluation(assignmentPattern as ParseNode.ObjectAssignmentPattern | ParseNode.ArrayAssignmentPattern, rval));
+    // 5. Return rval.
+    return rval;
+  } else if (AssignmentOperator === '&&=') {
+    // 1. Let lref be the result of evaluating LeftHandSideExpression.
+    const lref = Q(yield* Evaluate(LeftHandSideExpression));
+    // 2. Let lval be ? GetValue(lref).
+    const lval = Q(yield* 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;
+    }
+    let rval;
+    // 5. If IsAnonymousFunctionDefinition(AssignmentExpression) is true and IsIdentifierRef of LeftHandSideExpression is true, then
+    if (IsAnonymousFunctionDefinition(AssignmentExpression) && IsIdentifierRef(LeftHandSideExpression)) {
+      // a. Let rval be NamedEvaluation of AssignmentExpression with argument GetReferencedName(lref).
+      rval = Q(yield* NamedEvaluation(AssignmentExpression as FunctionDeclaration, (lref as ReferenceRecord).ReferencedName as JSStringValue));
+    } else { // 6. Else,
+      // a. Let rref be the result of evaluating AssignmentExpression.
+      const rref = Q(yield* Evaluate(AssignmentExpression));
+      // b. Let rval be ? GetValue(rref).
+      rval = Q(yield* GetValue(rref));
+    }
+    // 7. Perform ? PutValue(lref, rval).
+    Q(yield* PutValue(lref, rval));
+    // 8. Return rval.
+    return rval;
+  } else if (AssignmentOperator === '||=') {
+    // 1. Let lref be the result of evaluating LeftHandSideExpression.
+    const lref = Q(yield* Evaluate(LeftHandSideExpression));
+    // 2. Let lval be ? GetValue(lref).
+    const lval = Q(yield* GetValue(lref));
+    // 3. Let lbool be ! ToBoolean(lval).
+    const lbool = X(ToBoolean(lval));
+    // 4. If lbool is true, return lval.
+    if (lbool === Value.true) {
+      return lval;
+    }
+    let rval;
+    // 5. If IsAnonymousFunctionDefinition(AssignmentExpression) is true and IsIdentifierRef of LeftHandSideExpression is true, then
+    if (IsAnonymousFunctionDefinition(AssignmentExpression) && IsIdentifierRef(LeftHandSideExpression)) {
+      // a. Let rval be NamedEvaluation of AssignmentExpression with argument GetReferencedName(lref).
+      rval = Q(yield* NamedEvaluation(AssignmentExpression as FunctionDeclaration, (lref as ReferenceRecord).ReferencedName as JSStringValue));
+    } else { // 6. Else,
+      // a. Let rref be the result of evaluating AssignmentExpression.
+      const rref = Q(yield* Evaluate(AssignmentExpression));
+      // b. Let rval be ? GetValue(rref).
+      rval = Q(yield* GetValue(rref));
+    }
+    // 7. Perform ? PutValue(lref, rval).
+    Q(yield* PutValue(lref, rval));
+    // 8. Return rval.
+    return rval;
+  } else if (AssignmentOperator === '??=') {
+    // 1.Let lref be the result of evaluating LeftHandSideExpression.
+    const lref = Q(yield* Evaluate(LeftHandSideExpression));
+    // 2. Let lval be ? GetValue(lref).
+    const lval = Q(yield* GetValue(lref));
+    // 3. If lval is not undefined nor null, return lval.
+    if (lval !== Value.undefined && lval !== Value.null) {
+      return lval;
+    }
+    let rval;
+    // 4. If IsAnonymousFunctionDefinition(AssignmentExpression) is true and IsIdentifierRef of LeftHandSideExpression is true, then
+    if (IsAnonymousFunctionDefinition(AssignmentExpression) && IsIdentifierRef(LeftHandSideExpression)) {
+      // a. Let rval be NamedEvaluation of AssignmentExpression with argument GetReferencedName(lref).
+      rval = Q(yield* NamedEvaluation(AssignmentExpression as FunctionDeclaration, (lref as ReferenceRecord).ReferencedName as JSStringValue));
+    } else { // 5. Else,
+      // a. Let rref be the result of evaluating AssignmentExpression.
+      const rref = Q(yield* Evaluate(AssignmentExpression));
+      // b. Let rval be ? GetValue(rref).
+      rval = Q(yield* GetValue(rref));
+    }
+    // 6. Perform ? PutValue(lref, rval).
+    Q(yield* PutValue(lref, rval));
+    // 7. Return rval.
+    return rval;
+  } else {
+    // 1. Let lref be the result of evaluating LeftHandSideExpression.
+    const lref = Q(yield* Evaluate(LeftHandSideExpression));
+    // 2. Let lval be ? GetValue(lref).
+    const lval = Q(yield* GetValue(lref));
+    // 3. Let rref be the result of evaluating AssignmentExpression.
+    const rref = Q(yield* Evaluate(AssignmentExpression));
+    // 4. Let rval be ? GetValue(rref).
+    const rval = Q(yield* GetValue(rref));
+    // 5. Let assignmentOpText be the source text matched by AssignmentOperator.
+    const assignmentOpText = AssignmentOperator;
+    // 6. Let opText be the sequence of Unicode code points associated with assignmentOpText in the following table:
+    const opText = ({
+      '**=': '**',
+      '*=': '*',
+      '/=': '/',
+      '%=': '%',
+      '+=': '+',
+      '-=': '-',
+      '<<=': '<<',
+      '>>=': '>>',
+      '>>>=': '>>>',
+      '&=': '&',
+      '^=': '^',
+      '|=': '|',
+    } as const)[assignmentOpText];
+    // 7. Let r be ApplyStringOrNumericBinaryOperator(lval, opText, rval).
+    const r = Q(yield* ApplyStringOrNumericBinaryOperator(lval, opText, rval));
+    // 8. Perform ? PutValue(lref, r).
+    Q(yield* PutValue(lref, r));
+    // 9. Return r.
+    return r;
+  }
+}

package/src/runtime-semantics/AsyncArrowFunction.mts

@@ -0,0 +1,8 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { InstantiateAsyncArrowFunctionExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-async-arrow-function-definitions-runtime-semantics-evaluation */
+export function Evaluate_AsyncArrowFunction(AsyncArrowFunction: ParseNode.AsyncArrowFunction) {
+  // 1. Return InstantiateAsyncArrowFunctionExpression of AsyncArrowFunction.
+  return InstantiateAsyncArrowFunctionExpression(AsyncArrowFunction);
+}

package/src/runtime-semantics/AsyncFunctionExpression.mts

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

package/src/runtime-semantics/AsyncGeneratorExpression.mts

@@ -0,0 +1,11 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { InstantiateAsyncGeneratorFunctionExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-asyncgenerator-definitions-evaluation */
+//   AsyncGeneratorExpression :
+//     `async` `function` `*` `(` FormalParameters `)` `{` AsyncGeneratorBody `}`
+//     `async` `function` `*` BindingIdentifier `(` FormalParameters `)` `{` AsyncGeneratorBody `}`
+export function Evaluate_AsyncGeneratorExpression(AsyncGeneratorExpression: ParseNode.AsyncGeneratorExpression) {
+  // 1. Return InstantiateAsyncGeneratorFunctionExpression of AsyncGeneratorExpression.
+  return InstantiateAsyncGeneratorFunctionExpression(AsyncGeneratorExpression);
+}

package/src/runtime-semantics/AwaitExpression.mts

@@ -0,0 +1,16 @@
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Await, Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { GetValue, surroundingAgent } from '#self';
+
+/** https://tc39.es/ecma262/#sec-async-function-definitions-runtime-semantics-evaluation */
+//   AwaitExpression : `await` UnaryExpression
+export function* Evaluate_AwaitExpression({ UnaryExpression }: ParseNode.AwaitExpression): ValueEvaluator {
+  Q(surroundingAgent.debugger_cannotPreview);
+  // 1. Let exprRef be the result of evaluating UnaryExpression.
+  const exprRef = Q(yield* Evaluate(UnaryExpression));
+  // 2. Let value be ? GetValue(exprRef).
+  const value = Q(yield* GetValue(exprRef));
+  // 3. Return ? Await(value).
+  return Q(yield* Await(value));
+}

package/src/runtime-semantics/BindingInitialization.mts

@@ -0,0 +1,91 @@
+import { JSStringValue, Value } from '../value.mts';
+import {
+  EnsureCompletion,
+  EnvironmentRecord, StringValue, UndefinedValue,
+} from '../index.mts';
+import { NormalCompletion, Q } from '../completion.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import {
+  IteratorBindingInitialization_ArrayBindingPattern,
+  PropertyBindingInitialization,
+  RestBindingInitialization,
+} from './all.mts';
+import {
+  Assert,
+  PutValue,
+  ResolveBinding,
+  RequireObjectCoercible,
+  GetIterator,
+  IteratorClose,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-initializeboundname */
+export function* InitializeBoundName(name: JSStringValue, value: Value, environment: EnvironmentRecord | UndefinedValue): PlainEvaluator {
+  // 1. Assert: Type(name) is String.
+  Assert(name instanceof JSStringValue);
+  // 2. If environment is not undefined, then
+  if (!(environment instanceof UndefinedValue)) {
+    // a. Perform environment.InitializeBinding(name, value).
+    yield* environment.InitializeBinding(name, value);
+    // b. Return NormalCompletion(undefined).
+    return NormalCompletion(undefined);
+  } else {
+    // a. Let lhs be ResolveBinding(name).
+    const lhs = Q(yield* ResolveBinding(name, undefined, false));
+    // b. Return ? PutValue(lhs, value).
+    return Q(yield* PutValue(lhs, value));
+  }
+}
+
+// ObjectBindingPattern :
+//   `{` `}`
+//   `{` BindingPropertyList `}`
+//   `{` BindingRestProperty `}`
+//   `{` BindingPropertyList `,` BindingRestProperty `}`
+function* BindingInitialization_ObjectBindingPattern({ BindingPropertyList, BindingRestProperty }: ParseNode.ObjectBindingPattern, value: Value, environment: EnvironmentRecord | UndefinedValue): PlainEvaluator {
+  // 1. Perform ? PropertyBindingInitialization for BindingPropertyList using value and environment as the arguments.
+  const excludedNames = Q(yield* PropertyBindingInitialization(BindingPropertyList, value, environment));
+  if (BindingRestProperty) {
+    Q(yield* RestBindingInitialization(BindingRestProperty, value, environment, excludedNames));
+  }
+  // 2. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}
+
+export function* BindingInitialization(node: ParseNode.ForBinding | ParseNode.BindingIdentifier | ParseNode.ObjectBindingPattern | ParseNode.ArrayBindingPattern | ParseNode.BindingPattern, value: Value, environment: EnvironmentRecord | UndefinedValue): PlainEvaluator {
+  switch (node.type) {
+    case 'ForBinding':
+      if (node.BindingIdentifier) {
+        return yield* BindingInitialization(node.BindingIdentifier, value, environment);
+      }
+      return yield* BindingInitialization(node.BindingPattern!, value, environment);
+    case 'BindingIdentifier': {
+      // 1. Let name be StringValue of Identifier.
+      const name = StringValue(node);
+      // 2. Return ? InitializeBoundName(name, value, environment).
+      return Q(yield* InitializeBoundName(name, value, environment));
+    }
+    case 'ObjectBindingPattern': {
+      // 1. Perform ? RequireObjectCoercible(value).
+      Q(RequireObjectCoercible(value));
+      // 2. Return the result of performing BindingInitialization for ObjectBindingPattern using value and environment as arguments.
+      return yield* BindingInitialization_ObjectBindingPattern(node, value, environment);
+    }
+    case 'ArrayBindingPattern': {
+      // 1. Let iteratorRecord be ? GetIterator(value).
+      const iteratorRecord = Q(yield* GetIterator(value, 'sync'));
+      // 2. Let result be IteratorBindingInitialization of ArrayBindingPattern with arguments iteratorRecord and environment.
+      const result = EnsureCompletion(yield* IteratorBindingInitialization_ArrayBindingPattern(node, iteratorRecord, environment));
+      // 3. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, result).
+      if (iteratorRecord.Done === Value.false) {
+        return Q(yield* IteratorClose(iteratorRecord, result));
+      }
+      // 4. Return ? result.
+      return result;
+    }
+    default:
+      throw OutOfRange.exhaustive(node);
+  }
+}

package/src/runtime-semantics/BitwiseOperators.mts

@@ -0,0 +1,14 @@
+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-binary-bitwise-operators-runtime-semantics-evaluation */
+//   BitwiseANDExpression : BitwiseANDExpression `&` EqualityExpression
+//   BitwiseXORExpression : BitwiseXORExpression `^` BitwiseANDExpression
+//   BitwiseORExpression : BitwiseORExpression `|` BitwiseXORExpression
+// The production A : A @ B, where @ is one of the bitwise operators in the
+// productions above, is evaluated as follows:
+export function* Evaluate_BinaryBitwiseExpression({ A, operator, B }: ParseNode.BitwiseANDExpression | ParseNode.BitwiseXORExpression | ParseNode.BitwiseORExpression): ValueEvaluator {
+  return Q(yield* EvaluateStringOrNumericBinaryExpression(A, operator, B));
+}

package/src/runtime-semantics/Block.mts

@@ -0,0 +1,73 @@
+import { Value } from '../value.mts';
+import {
+  LexicallyScopedDeclarations,
+  IsConstantDeclaration,
+  BoundNames,
+} from '../static-semantics/all.mts';
+import { EnsureCompletion, X, NormalCompletion } from '../completion.mts';
+import { DisposeResources } from '../abstract-ops/disposable-operations.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { Evaluate_StatementList, InstantiateFunctionObject } from './all.mts';
+import { surroundingAgent, Assert, DeclarativeEnvironmentRecord } from '#self';
+
+/** https://tc39.es/ecma262/#sec-blockdeclarationinstantiation */
+export function* BlockDeclarationInstantiation(code: ParseNode.StatementList | ParseNode.CaseBlock, env: DeclarativeEnvironmentRecord) {
+  // 1. Assert: env is a declarative Environment Record.
+  Assert(env instanceof DeclarativeEnvironmentRecord);
+  // 2. Let declarations be the LexicallyScopedDeclarations of code.
+  const declarations = LexicallyScopedDeclarations(code);
+  // 3. Let privateEnv be the running execution context's PrivateEnvironment.
+  const privateEnv = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 4. For each element d in declarations, do
+  for (const d of declarations) {
+    // a. 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 ! env.CreateImmutableBinding(dn, true).
+        X(env.CreateImmutableBinding(dn, Value.true));
+      } else { // ii. Else,
+        // 1. Perform ! env.CreateMutableBinding(dn, false).
+        X(env.CreateMutableBinding(dn, Value.false));
+      }
+      // b. If d is a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration, then
+      if (d.type === 'FunctionDeclaration'
+          || d.type === 'GeneratorDeclaration'
+          || d.type === 'AsyncFunctionDeclaration'
+          || d.type === 'AsyncGeneratorDeclaration') {
+        // i. Let fn be the sole element of the BoundNames of d.
+        const fn = BoundNames(d)[0];
+        // ii. Let fo be InstantiateFunctionObject of d with argument env.
+        const fo = InstantiateFunctionObject(d, env, privateEnv);
+        // iii. Perform env.InitializeBinding(fn, fo).
+        yield* env.InitializeBinding(fn, fo);
+      }
+    }
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-block-runtime-semantics-evaluation */
+//  Block :
+//    `{` `}`
+//    `{` StatementList `}`
+export function* Evaluate_Block({ StatementList }: ParseNode.Block) {
+  if (StatementList.length === 0) {
+    // 1. Return NormalCompletion(empty).
+    return NormalCompletion(undefined);
+  }
+  // 1. Let oldEnv be the running execution context's LexicalEnvironment.
+  const oldEnv = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 2. Let blockEnv be NewDeclarativeEnvironment(oldEnv).
+  const blockEnv = new DeclarativeEnvironmentRecord(oldEnv);
+  // 3. Perform BlockDeclarationInstantiation(StatementList, blockEnv).
+  yield* BlockDeclarationInstantiation(StatementList, blockEnv);
+  // 4. Set the running execution context's LexicalEnvironment to blockEnv.
+  surroundingAgent.runningExecutionContext.LexicalEnvironment = blockEnv;
+  // 5. Let blockValue be the result of evaluating StatementList.
+  let blockValue = EnsureCompletion(yield* Evaluate_StatementList(StatementList));
+  blockValue = yield* DisposeResources(blockEnv.DisposableResourceStack, blockValue);
+  // 6. Set the running execution context's LexicalEnvironment to oldEnv.
+  surroundingAgent.runningExecutionContext.LexicalEnvironment = oldEnv;
+  // 7. Return blockValue.
+  return blockValue;
+}

package/src/runtime-semantics/BreakStatement.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-break-statement-runtime-semantics-evaluation */
+//   BreakStatement :
+//     `break` `;`
+//     `break` LabelIdentifier `;`
+export function Evaluate_BreakStatement({ LabelIdentifier }: ParseNode.BreakStatement) {
+  if (!LabelIdentifier) {
+    // 1. Return Completion { [[Type]]: break, [[Value]]: empty, [[Target]]: empty }.
+    return new Completion({ Type: 'break', Value: undefined, Target: undefined });
+  }
+  // 1. Let label be the StringValue of LabelIdentifier.
+  const label = StringValue(LabelIdentifier);
+  // 2. Return Completion { [[Type]]: break, [[Value]]: empty, [[Target]]: label }.
+  return new Completion({ Type: 'break', Value: undefined, Target: label });
+}

package/src/runtime-semantics/BreakableStatement.mts

@@ -0,0 +1,18 @@
+import { JSStringSet } from '../utils/container.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { LabelledEvaluation } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation */
+//   BreakableStatement :
+//     IterationStatement
+//     SwitchStatement
+//
+//   IterationStatement :
+//     (DoStatement)
+//     (WhileStatement)
+export function Evaluate_BreakableStatement(BreakableStatement: ParseNode.BreakableStatement) {
+  // 1. Let newLabelSet be a new empty List.
+  const newLabelSet = new JSStringSet();
+  // 2. Return the result of performing LabelledEvaluation of this BreakableStatement with argument newLabelSet.
+  return LabelledEvaluation(BreakableStatement, newLabelSet);
+}