@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/runtime-semantics/ContinueStatement.mts

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

package/src/runtime-semantics/CreateDynamicFunction.mts

@@ -0,0 +1,200 @@
+import {
+  Assert,
+  DefinePropertyOrThrow,
+  GetPrototypeFromConstructor,
+  MakeConstructor,
+  OrdinaryFunctionCreate,
+  OrdinaryObjectCreate,
+  SetFunctionName,
+  ToString,
+  type FunctionObject,
+  type Intrinsics,
+} from '../abstract-ops/all.mts';
+import { Q, ThrowCompletion, X } from '../completion.mts';
+import {
+  HostEnsureCanCompileStrings,
+  surroundingAgent,
+} from '../host-defined/engine.mts';
+import { wrappedParse } from '../parse.mts';
+import { Token } from '../parser/tokens.mts';
+import {
+  Descriptor, UndefinedValue, Value,
+  type Arguments,
+} from '../value.mts';
+import { __ts_cast__, OutOfRange } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+// #table-dynamic-function-sourcetext-prefixes
+const DynamicFunctionSourceTextPrefixes = {
+  'normal': 'function',
+  'generator': 'function*',
+  'async': 'async function',
+  'asyncGenerator': 'async function*',
+};
+
+export function* CreateDynamicFunction(constructor: FunctionObject, newTarget: FunctionObject | UndefinedValue, kind: 'normal' | 'generator' | 'async' | 'asyncGenerator', args: Arguments) {
+  // 1. Assert: The execution context stack has at least two elements.
+  Assert(surroundingAgent.executionContextStack.length >= 2);
+  // 2. Let callerContext be the second to top element of the execution context stack.
+  const callerContext = surroundingAgent.executionContextStack[surroundingAgent.executionContextStack.length - 2];
+  // 3. Let callerRealm be callerContext's Realm.
+  const callerRealm = callerContext.Realm;
+  // 4. Let calleeRealm be the current Realm Record.
+  const calleeRealm = surroundingAgent.currentRealmRecord;
+  // 5. Perform ? HostEnsureCanCompileStrings(callerRealm, calleeRealm).
+  Q(HostEnsureCanCompileStrings(callerRealm, calleeRealm));
+  // 6. If newTarget is undefined, set newTarget to constructor.
+  if (newTarget instanceof UndefinedValue) {
+    newTarget = constructor;
+  }
+  // 7. If kind is normal, then
+  let fallbackProto: keyof Intrinsics;
+  if (kind === 'normal') {
+    // a. Let goal be the grammar symbol FunctionBody[~Yield, ~Await].
+    // b. Let parameterGoal be the grammar symbol FormalParameters[~Yield, ~Await].
+    // c. Let fallbackProto be "%Function.prototype%".
+    fallbackProto = '%Function.prototype%';
+  } else if (kind === 'generator') { // 8. Else if kind is generator, then
+    // a. Let goal be the grammar symbol GeneratorBody.
+    // b. Let parameterGoal be the grammar symbol FormalParameters[+Yield, ~Await].
+    // c. Let fallbackProto be "%GeneratorFunction.prototype%".
+    fallbackProto = '%GeneratorFunction.prototype%';
+  } else if (kind === 'async') { // 9. Else if kind is async, then
+    // a. Let goal be the grammar symbol AsyncBody.
+    // b. Let parameterGoal be the grammar symbol FormalParameters[~Yield, +Await].
+    // c. Let fallbackProto be "%AsyncFunction.prototype%".
+    fallbackProto = '%AsyncFunction.prototype%';
+  } else { // 10. Else,
+    // a. Assert: kind is asyncGenerator.
+    Assert(kind === 'asyncGenerator');
+    // b. Let goal be the grammar symbol AsyncGeneratorBody.
+    // c. Let parameterGoal be the grammar symbol FormalParameters[+Yield, +Await].
+    // d. Let fallbackProto be "%AsyncGeneratorFunction.prototype%".
+    fallbackProto = '%AsyncGeneratorFunction.prototype%';
+  }
+  // 11. Let argCount be the number of elements in args.
+  const argCount = args.length;
+  // 12. Let P be the empty String.
+  let P = '';
+  // 13. If argCount = 0, let bodyArg be the empty String.
+  let bodyArg;
+  if (argCount === 0) {
+    bodyArg = Value('');
+  } else if (argCount === 1) { // 14. Else if argCount = 1, let bodyArg be args[0].
+    bodyArg = args[0];
+  } else { // 15. Else,
+    // a. Assert: argCount > 1.
+    Assert(argCount > 1);
+    // b. Let firstArg be args[0].
+    const firstArg = args[0];
+    // c. Set P to ? ToString(firstArg).
+    P = Q(yield* ToString(firstArg)).stringValue();
+    // d. Let k be 1.
+    let k = 1;
+    // e. Repeat, while k < argCount - 1
+    while (k < argCount - 1) {
+      // i. Let nextArg be args[k].
+      const nextArg = args[k];
+      // ii. Let nextArgString be ? ToString(nextArg).
+      const nextArgString = Q(yield* ToString(nextArg));
+      // iii. Set P to the string-concatenation of the previous value of P, "," (a comma), and nextArgString.
+      P = `${P},${nextArgString.stringValue()}`;
+      // iv. Set k to k + 1.
+      k += 1;
+    }
+    // f. Let bodyArg be args[k].
+    bodyArg = args[k];
+  }
+  // 16. Let bodyString be the string-concatenation of 0x000A (LINE FEED), ? ToString(bodyArg), and 0x000A (LINE FEED).
+  const bodyString = `\u{000A}${Q(yield* ToString(bodyArg)).stringValue()}\u{000A}`;
+  // 17. Let prefix be the prefix associated with kind in Table 48.
+  const prefix = DynamicFunctionSourceTextPrefixes[kind];
+  // 18. Let sourceString be the string-concatenation of prefix, " anonymous(", P, 0x000A (LINE FEED), ") {", bodyString, and "}".
+  const sourceString = `${prefix} anonymous(${P}\u{000A}) {${bodyString}}`;
+  // 19. Let sourceText be ! UTF16DecodeString(sourceString).
+  const sourceText = sourceString;
+  // 20. Perform the following substeps in an implementation-dependent order, possibly interleaving parsing and error detection:
+  //   a. Let parameters be the result of parsing ! UTF16DecodeString(P), using parameterGoal as the goal symbol. Throw a SyntaxError exception if the parse fails.
+  //   b. Let body be the result of parsing ! UTF16DecodeString(bodyString), using goal as the goal symbol. Throw a SyntaxError exception if the parse fails.
+  //   c. Let strict be ContainsUseStrict of body.
+  //   d. If any static semantics errors are detected for parameters or body, throw a SyntaxError exception. If strict is true, the Early Error rules for UniqueFormalParameters:FormalParameters are applied.
+  //   e. If strict is true and IsSimpleParameterList of parameters is false, throw a SyntaxError exception.
+  //   f. If any element of the BoundNames of parameters also occurs in the LexicallyDeclaredNames of body, throw a SyntaxError exception.
+  //   g. If body Contains SuperCall is true, throw a SyntaxError exception.
+  //   h. If parameters Contains SuperCall is true, throw a SyntaxError exception.
+  //   i. If body Contains SuperProperty is true, throw a SyntaxError exception.
+  //   j. If parameters Contains SuperProperty is true, throw a SyntaxError exception.
+  //   k. If kind is generator or asyncGenerator, then
+  //     i. If parameters Contains YieldExpression is true, throw a SyntaxError exception.
+  //   l. If kind is async or asyncGenerator, then
+  //     i. If parameters Contains AwaitExpression is true, throw a SyntaxError exception.
+  //   m. If strict is true, then
+  //     i. If BoundNames of parameters contains any duplicate elements, throw a SyntaxError exception.
+  let parameters;
+  let body;
+  {
+    const f = wrappedParse({ source: sourceString }, (p) => {
+      const r = p.parseExpression();
+      p.expect(Token.EOS);
+      return r;
+    });
+    if (Array.isArray(f)) {
+      return ThrowCompletion(f[0]);
+    }
+    __ts_cast__<ParseNode.FunctionExpression | ParseNode.GeneratorExpression | ParseNode.AsyncFunctionExpression | ParseNode.AsyncGeneratorExpression>(f);
+    parameters = f.FormalParameters;
+    switch (kind) {
+      case 'normal':
+        body = (f as ParseNode.FunctionExpression).FunctionBody;
+        break;
+      case 'generator':
+        body = (f as ParseNode.GeneratorExpression).GeneratorBody;
+        break;
+      case 'async':
+        body = (f as ParseNode.AsyncFunctionExpression).AsyncBody;
+        break;
+      case 'asyncGenerator':
+        body = (f as ParseNode.AsyncGeneratorExpression).AsyncGeneratorBody;
+        break;
+      default:
+        throw new OutOfRange('kind', kind);
+    }
+  }
+  // 21. Let proto be ? GetPrototypeFromConstructor(newTarget, fallbackProto).
+  const proto = Q(yield* GetPrototypeFromConstructor(newTarget, fallbackProto));
+  // 22. Let realmF be the current Realm Record.
+  const realmF = surroundingAgent.currentRealmRecord;
+  // 23. Let scope be realmF.[[GlobalEnv]].
+  const scope = realmF.GlobalEnv;
+  // 24. Let F be ! OrdinaryFunctionCreate(proto, sourceText, parameters, body, non-lexical-this, scope, null).
+  const F = X(OrdinaryFunctionCreate(proto, sourceText, parameters, body, 'non-lexical-this', scope, Value.null));
+  // 25. Perform SetFunctionName(F, "anonymous").
+  SetFunctionName(F, Value('anonymous'));
+  // 26. If kind is generator, then
+  if (kind === 'generator') {
+    // a. Let prototype be OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
+    const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype%'));
+    // b. Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+    X(DefinePropertyOrThrow(F, Value('prototype'), Descriptor({
+      Value: prototype,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+    })));
+  } else if (kind === 'asyncGenerator') { // 27. Else if kind is asyncGenerator, then
+    // a. Let prototype be OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
+    const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype.prototype%'));
+    // b. Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+    X(DefinePropertyOrThrow(F, Value('prototype'), Descriptor({
+      Value: prototype,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+    })));
+  } else if (kind === 'normal') { // 28. Else if kind is normal, then perform MakeConstructor(F).
+    MakeConstructor(F);
+  }
+  // 29. NOTE: Functions whose kind is async are not constructible and do not have a [[Construct]] internal method or a "prototype" property.
+  // 20. Return F.
+  return F;
+}

package/src/runtime-semantics/DebuggerStatement.mts

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

package/src/runtime-semantics/DefineMethod.mts

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

package/src/runtime-semantics/DestructuringAssignmentEvaluation.mts

@@ -0,0 +1,306 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  JSStringValue, ReferenceRecord, Value, type PropertyKeyValue,
+} from '../value.mts';
+import {
+  ArrayCreate,
+  CopyDataProperties,
+  CreateDataPropertyOrThrow,
+  GetIterator,
+  GetV,
+  GetValue,
+  IteratorClose,
+  IteratorStep,
+  OrdinaryObjectCreate,
+  PutValue,
+  ResolveBinding,
+  RequireObjectCoercible,
+  ToString,
+  F,
+  Assert,
+  type IteratorRecord,
+  IteratorStepValue,
+} from '../abstract-ops/all.mts';
+import {
+  IsAnonymousFunctionDefinition,
+  IsIdentifierRef,
+  StringValue,
+  type FunctionDeclaration,
+} from '../static-semantics/all.mts';
+import {
+  Evaluate, type PlainEvaluator, type StatementEvaluator,
+} from '../evaluator.mts';
+import {
+  Q, X,
+  Completion,
+  AbruptCompletion,
+  NormalCompletion,
+  EnsureCompletion,
+} from '../completion.mts';
+import { OutOfRange } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Evaluate_PropertyName,
+  NamedEvaluation,
+  refineLeftHandSideExpression,
+} from './all.mts';
+
+// ObjectAssignmentPattern :
+//  `{` `}`
+//  `{` AssignmentPropertyList `}`
+//  `{` AssignmentPropertyList `,` `}`
+//  `{` AssignmentPropertyList `,` AssignmentRestProperty? `}`
+function* DestructuringAssignmentEvaluation_ObjectAssignmentPattern({ AssignmentPropertyList, AssignmentRestProperty }: ParseNode.ObjectAssignmentPattern, value: Value): PlainEvaluator {
+  // 1. Perform ? RequireObjectCoercible(value).
+  Q(RequireObjectCoercible(value));
+  // 2. Perform ? PropertyDestructuringAssignmentEvaluation for AssignmentPropertyList using value as the argument.
+  const excludedNames: readonly PropertyKeyValue[] = Q(yield* PropertyDestructuringAssignmentEvaluation(AssignmentPropertyList, value));
+  if (AssignmentRestProperty) {
+    Q(yield* RestDestructuringAssignmentEvaluation(AssignmentRestProperty, value, excludedNames));
+  }
+  // 3. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-restdestructuringassignmentevaluation */
+// AssignmentRestProperty : `...` DestructuringAssignmentTarget
+function* RestDestructuringAssignmentEvaluation({ DestructuringAssignmentTarget }: ParseNode.AssignmentRestProperty, value: Value, excludedNames: readonly PropertyKeyValue[]): StatementEvaluator {
+  // 1. Let lref be the result of evaluating DestructuringAssignmentTarget.
+  const lref = Q(yield* Evaluate(DestructuringAssignmentTarget));
+  Q(lref);
+  // 3. Let restObj be OrdinaryObjectCreate(%Object.prototype%).
+  const restObj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  // 4. Perform ? CopyDataProperties(restObj, value, excludedNames).
+  Q(yield* CopyDataProperties(restObj, value, excludedNames));
+  // 5. Return PutValue(lref, restObj).
+  return yield* PutValue(lref, restObj);
+}
+
+function* PropertyDestructuringAssignmentEvaluation(AssignmentPropertyList: ParseNode.ObjectAssignmentPattern['AssignmentPropertyList'], value: Value): PlainEvaluator<PropertyKeyValue[]> {
+  const propertyNames: PropertyKeyValue[] = [];
+  for (const AssignmentProperty of AssignmentPropertyList) {
+    if ('IdentifierReference' in AssignmentProperty) {
+      // 1. Let P be StringValue of IdentifierReference.
+      const P = StringValue(AssignmentProperty.IdentifierReference);
+      // 2. Let lref be ? ResolveBinding(P).
+      const lref = Q(yield* ResolveBinding(P, undefined, AssignmentProperty.IdentifierReference.strict));
+      // 3. Let v be ? GetV(value, P).
+      let v = Q(yield* GetV(value, P));
+      // 4. If Initializer? is present and v is undefined, then
+      if (AssignmentProperty.Initializer && v === Value.undefined) {
+        // a. If IsAnonymousFunctionDefinition(Initializer) is true, then
+        if (IsAnonymousFunctionDefinition(AssignmentProperty.Initializer)) {
+          // i. Set v to the result of performing NamedEvaluation for Initializer with argument P.
+          v = Q(yield* NamedEvaluation(AssignmentProperty.Initializer as FunctionDeclaration, P));
+        } else { // b. Else,
+          // i. Let defaultValue be the result of evaluating Initializer.
+          const defaultValue = Q(yield* Evaluate(AssignmentProperty.Initializer));
+          // ii. Set v to ? GetValue(defaultValue)
+          v = Q(yield* GetValue(defaultValue));
+        }
+      }
+      // 5. Perform ? PutValue(lref, v).
+      Q(yield* PutValue(lref, v));
+      // 6. Return a new List containing P.
+      propertyNames.push(P);
+    } else {
+      Assert('PropertyName' in AssignmentProperty);
+      // 1. Let name be the result of evaluating PropertyName.
+      const name = yield* Evaluate_PropertyName(AssignmentProperty.PropertyName!);
+      Q(name);
+      // 3. Perform ? KeyedDestructuringAssignmentEvaluation of AssignmentElement with value and name as the arguments.
+      Q(yield* KeyedDestructuringAssignmentEvaluation(AssignmentProperty.AssignmentElement, value, name as PropertyKeyValue));
+      // 4. Return a new List containing name.
+      propertyNames.push(name as PropertyKeyValue);
+    }
+  }
+  return propertyNames;
+}
+
+// AssignmentElement : DestructuringAssignmentTarget Initializer?
+function* KeyedDestructuringAssignmentEvaluation({
+  DestructuringAssignmentTarget,
+  Initializer,
+}: ParseNode.AssignmentElement, value: Value, propertyName: PropertyKeyValue) {
+  // 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
+  let lref;
+  if (DestructuringAssignmentTarget.type !== 'ObjectLiteral'
+      && DestructuringAssignmentTarget.type !== 'ArrayLiteral') {
+    // a. Let lref be the result of evaluating DestructuringAssignmentTarget.
+    lref = Q(yield* Evaluate(DestructuringAssignmentTarget));
+  }
+  // 2. Let v be ? GetV(value, propertyName).
+  const v = Q(yield* GetV(value, propertyName));
+  // 3. If Initializer is present and v is undefined, then
+  let rhsValue: Value;
+  if (Initializer && v === Value.undefined) {
+    // a. If IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of DestructuringAssignmentTarget are both true, then
+    if (IsAnonymousFunctionDefinition(Initializer) && IsIdentifierRef(DestructuringAssignmentTarget)) {
+      // i. Let rhsValue be NamedEvaluation of Initializer with argument GetReferencedName(lref).
+      rhsValue = Q(yield* NamedEvaluation(Initializer as FunctionDeclaration, (lref as ReferenceRecord).ReferencedName as JSStringValue));
+    } else {
+      // i. Let defaultValue be the result of evaluating Initializer.
+      const defaultValue = Q(yield* Evaluate(Initializer));
+      // ii. Let rhsValue be ? GetValue(defaultValue).
+      rhsValue = Q(yield* GetValue(defaultValue));
+    }
+  } else { // 4. Else, let rhsValue be v.
+    rhsValue = v;
+  }
+  // 5. If DestructuringAssignmentTarget is an ObjectLiteral or an ArrayLiteral, then
+  if (DestructuringAssignmentTarget.type === 'ObjectLiteral'
+      || DestructuringAssignmentTarget.type === 'ArrayLiteral') {
+    // a. Let assignmentPattern be the AssignmentPattern that is covered by DestructuringAssignmentTarget.
+    const assignmentPattern = refineLeftHandSideExpression(DestructuringAssignmentTarget) as ParseNode.ObjectAssignmentPattern | ParseNode.ArrayAssignmentPattern;
+    // b. Return the result of performing DestructuringAssignmentEvaluation of assignmentPattern with rhsValue as the argument.
+    return yield* DestructuringAssignmentEvaluation(assignmentPattern, X(rhsValue));
+  }
+  // 6. Return ? PutValue(lref, rhsValue).
+  return Q(yield* PutValue(X(lref)!, rhsValue));
+}
+
+// ArrayAssignmentPattern :
+//   `[` `]`
+//   `[` AssignmentElementList `]`
+//   `[` AssignmentElementList `,` AssignmentRestElement? `]`
+function* DestructuringAssignmentEvaluation_ArrayAssignmentPattern({ AssignmentElementList, AssignmentRestElement }: ParseNode.ArrayAssignmentPattern, value: Value) {
+  // 1. Let iteratorRecord be ? GetIterator(value).
+  const iteratorRecord = Q(yield* GetIterator(value, 'sync'));
+  // 2. Let status be IteratorDestructuringAssignmentEvaluation of AssignmentElementList with argument iteratorRecord.
+  let status = EnsureCompletion(yield* IteratorDestructuringAssignmentEvaluation(AssignmentElementList, iteratorRecord));
+  // 3. If status is an abrupt completion, then
+  if (status instanceof AbruptCompletion) {
+    // a. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, status).
+    if (iteratorRecord.Done === Value.false) {
+      return Q(yield* IteratorClose(iteratorRecord, status));
+    }
+    // b. Return Completion(status).
+    return status;
+  }
+  // 4. If Elision is present, then
+  // ...
+  // 5. If AssignmentRestElement is present, then
+  if (AssignmentRestElement) {
+    // a. Set status to the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentRestElement with iteratorRecord as the argument.
+    status = EnsureCompletion(yield* IteratorDestructuringAssignmentEvaluation(AssignmentRestElement, iteratorRecord));
+  }
+  // 6. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, status).
+  if (iteratorRecord.Done === Value.false) {
+    return Q(yield* IteratorClose(iteratorRecord, status));
+  }
+  return Completion(status);
+}
+
+function* IteratorDestructuringAssignmentEvaluation(node: ParseNode.AssignmentElisionElement[] | ParseNode.AssignmentElisionElement | ParseNode.AssignmentRestElement, iteratorRecord: IteratorRecord): StatementEvaluator {
+  if (Array.isArray(node)) {
+    for (const n of node) {
+      Q(yield* IteratorDestructuringAssignmentEvaluation(n, iteratorRecord));
+    }
+    return NormalCompletion(undefined);
+  }
+  switch (node.type) {
+    case 'Elision':
+      // 1. If iteratorRecord.[[Done]] is false, then
+      if (iteratorRecord.Done === Value.false) {
+        // a. Perform ? IteratorStep(iteratorRecord).
+        Q(yield* IteratorStep(iteratorRecord));
+      }
+      // 2. Return NormalCompletion(empty).
+      return NormalCompletion(undefined);
+    case 'AssignmentElement': {
+      const { DestructuringAssignmentTarget, Initializer } = node;
+      let lref;
+      // 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
+      if (DestructuringAssignmentTarget.type !== 'ObjectLiteral'
+          && DestructuringAssignmentTarget.type !== 'ArrayLiteral') {
+        lref = Q(yield* Evaluate(DestructuringAssignmentTarget));
+      }
+      let value: Value = Value.undefined;
+      // 2. If iteratorRecord.[[Done]] is false, then
+      if (iteratorRecord.Done === Value.false) {
+        // a. Let next be ? IteratorStepValue(iteratorRecord).
+        const next = Q(yield* IteratorStepValue(iteratorRecord));
+        // d. If next is not done, set value to next.
+        if (next !== 'done') {
+          value = next;
+        }
+      }
+      let v: Value;
+      // 4. If Initializer is present and value is undefined, then
+      if (Initializer && value === Value.undefined) {
+        // a. If IsAnonymousFunctionDefinition(AssignmentExpression) is true and IsIdentifierRef of LeftHandSideExpression is true, then
+        if (IsAnonymousFunctionDefinition(Initializer) && IsIdentifierRef(DestructuringAssignmentTarget)) {
+          // i. Let target be the StringValue of DestructuringAssignmentTarget.
+          const target = (lref as ReferenceRecord).ReferencedName as JSStringValue;
+          // i. ii. Let v be ? NamedEvaluation of Initializer with argument target.
+          v = Q(yield* NamedEvaluation(Initializer as FunctionDeclaration, target));
+        } else { // b. Else,
+          // i. Let defaultValue be the result of evaluating Initializer.
+          const defaultValue = Q(yield* Evaluate(Initializer));
+          // ii. Let v be ? GetValue(defaultValue).
+          v = Q(yield* GetValue(defaultValue));
+        }
+      } else { // 5. Else, let v be value.
+        v = Q(value);
+      }
+      // 6. If DestructuringAssignmentTarget is an ObjectLiteral or an ArrayLiteral, then
+      if (DestructuringAssignmentTarget.type === 'ObjectLiteral'
+          || DestructuringAssignmentTarget.type === 'ArrayLiteral') {
+        // a. Let nestedAssignmentPattern be the AssignmentPattern that is covered by DestructuringAssignmentTarget.
+        const nestedAssignmentPattern = refineLeftHandSideExpression(DestructuringAssignmentTarget) as ParseNode.ObjectAssignmentPattern | ParseNode.ArrayAssignmentPattern;
+        // b. Return the result of performing DestructuringAssignmentEvaluation of nestedAssignmentPattern with v as the argument.
+        return yield* DestructuringAssignmentEvaluation(nestedAssignmentPattern, X(v));
+      }
+      // 7. Return ? PutValue(lref, v).
+      return Q(yield* PutValue(Q(lref) as ReferenceRecord, v));
+    }
+    case 'AssignmentRestElement': {
+      const { AssignmentExpression: DestructuringAssignmentTarget } = node;
+      let lref;
+      // 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
+      if (DestructuringAssignmentTarget.type !== 'ObjectLiteral'
+          && DestructuringAssignmentTarget.type !== 'ArrayLiteral') {
+        lref = yield* Evaluate(DestructuringAssignmentTarget);
+        Q(lref);
+      }
+      // 2. Let A be ! ArrayCreate(0).
+      const A = X(ArrayCreate(0));
+      // 3. Let n be 0.
+      let n = 0;
+      // 4. Repeat, while iteratorRecord.[[Done]] is false,
+      while (iteratorRecord.Done === Value.false) {
+        // a. Let next be IteratorStep(iteratorRecord).
+        const next = Q(yield* IteratorStepValue(iteratorRecord));
+        // d. If next is not done, then
+        if (next !== 'done') {
+          // i. Perform ! CreateDataPropertyOrThrow(A, ! ToString(𝔽(n)), next).
+          X(CreateDataPropertyOrThrow(A, X(ToString(F(n))), X(next)));
+          // v. Set n to n + 1.
+          n += 1;
+        }
+      }
+      // 5. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
+      if (DestructuringAssignmentTarget.type !== 'ObjectLiteral'
+          && DestructuringAssignmentTarget.type !== 'ArrayLiteral') {
+        return Q(yield* PutValue(Q(lref) as ReferenceRecord, A));
+      }
+      // 6. Let nestedAssignmentPattern be the AssignmentPattern that is covered by DestructuringAssignmentTarget.
+      const nestedAssignmentPattern = refineLeftHandSideExpression(DestructuringAssignmentTarget) as ParseNode.ObjectAssignmentPattern | ParseNode.ArrayAssignmentPattern;
+      // 7. Return the result of performing DestructuringAssignmentEvaluation of nestedAssignmentPattern with A as the argument.
+      return yield* DestructuringAssignmentEvaluation(nestedAssignmentPattern, A);
+    }
+    default:
+      throw new OutOfRange('IteratorDestructuringAssignmentEvaluation', node);
+  }
+}
+
+export function DestructuringAssignmentEvaluation(node: ParseNode.ObjectAssignmentPattern | ParseNode.ArrayAssignmentPattern, value: Value): StatementEvaluator {
+  switch (node.type) {
+    case 'ObjectAssignmentPattern':
+      return DestructuringAssignmentEvaluation_ObjectAssignmentPattern(node, value);
+    case 'ArrayAssignmentPattern':
+      return DestructuringAssignmentEvaluation_ArrayAssignmentPattern(node, value);
+    default:
+      throw new OutOfRange('DestructuringAssignmentEvaluation', node);
+  }
+}

package/src/runtime-semantics/EmptyStatement.mts

@@ -0,0 +1,9 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-empty-statement-runtime-semantics-evaluation */
+//   EmptyStatement : `;`
+export function Evaluate_EmptyStatement(_EmptyStatement: ParseNode.EmptyStatement) {
+  // 1. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/EqualityExpression.mts

@@ -0,0 +1,60 @@
+import {
+  IsLooselyEqual,
+  GetValue,
+  IsStrictlyEqual,
+} from '../abstract-ops/all.mts';
+import { Q, X } from '../completion.mts';
+import { Evaluate } from '../evaluator.mts';
+import { Value } from '../value.mts';
+import { OutOfRange } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-equality-operators-runtime-semantics-evaluation */
+//   EqualityExpression :
+//     EqualityExpression `==` RelationalExpression
+//     EqualityExpression `!=` RelationalExpression
+//     EqualityExpression `===` RelationalExpression
+//     EqualityExpression `!==` RelationalExpression
+export function* Evaluate_EqualityExpression({ EqualityExpression, operator, RelationalExpression }: ParseNode.EqualityExpression) {
+  // 1. Let lref be the result of evaluating EqualityExpression.
+  const lref = Q(yield* Evaluate(EqualityExpression));
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(yield* GetValue(lref));
+  // 3. Let rref be the result of evaluating RelationalExpression.
+  const rref = Q(yield* Evaluate(RelationalExpression));
+  // 4. Let rval be ? GetValue(rref).
+  const rval = Q(yield* GetValue(rref));
+  switch (operator) {
+    case '==':
+      // 5. Return the result of performing Abstract Equality Comparison rval == lval.
+      return yield* IsLooselyEqual(rval, lval);
+    case '!=': {
+      // 5. Let r be the result of performing Abstract Equality Comparison rval == lval.
+      const r = yield* IsLooselyEqual(rval, lval);
+      Q(r);
+      // 7. If r is true, return false. Otherwise, return true.
+      if (r === Value.true) {
+        return Value.false;
+      } else {
+        return Value.true;
+      }
+    }
+    case '===':
+      // 5. Return the result of performing Strict Equality Comparison rval === lval.
+      return IsStrictlyEqual(rval, lval);
+    case '!==': {
+      // 5. Let r be the result of performing Strict Equality Comparison rval === lval.
+      // 6. Assert: r is a normal completion.
+      const r = X(IsStrictlyEqual(rval, lval));
+      // 7. If r.[[Value]] is true, return false. Otherwise, return true.
+      if (r === Value.true) {
+        return Value.false;
+      } else {
+        return Value.true;
+      }
+    }
+
+    default:
+      throw new OutOfRange('Evaluate_EqualityExpression', operator);
+  }
+}