@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

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 '../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(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(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(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(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 }).
+    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 }).
+    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,20 @@
+import { surroundingAgent } from '../engine.mts';
+import { NormalCompletion, EnsureCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-debugger-statement-runtime-semantics-evaluation */
+// DebuggerStatement : `debugger` `;`
+export function Evaluate_DebuggerStatement(_node: ParseNode.DebuggerStatement) {
+  let result;
+  // 1. If an implementation-defined debugging facility is available and enabled, then
+  if (surroundingAgent.hostDefinedOptions.onDebugger && !surroundingAgent.debugger_isPreviewing) {
+    // a. Perform an implementation-defined debugging action.
+    // b. Let result be an implementation-defined Completion value.
+    result = EnsureCompletion(surroundingAgent.hostDefinedOptions.onDebugger());
+  } else {
+    // a. Let result be NormalCompletion(empty).
+    result = NormalCompletion(undefined);
+  }
+  // 2. Return result.
+  return result;
+}

package/src/runtime-semantics/DefineMethod.mts

@@ -0,0 +1,42 @@
+import { surroundingAgent } from '../engine.mts';
+import { OrdinaryFunctionCreate, MakeMethod, sourceTextMatchedBy } from '../abstract-ops/all.mts';
+import { ReturnIfAbrupt } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { Evaluator } from '../evaluator.mts';
+import { Evaluate_PropertyName } from './all.mts';
+import type {
+  ECMAScriptFunctionObject, ObjectValue, PlainCompletion, 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): Evaluator<PlainCompletion<DefineMethodRecord>> {
+  const { ClassElementName, UniqueFormalParameters, FunctionBody } = MethodDefinition;
+  // 1. Let propKey be the result of evaluating ClassElementName.
+  const propKey = ReturnIfAbrupt(yield* Evaluate_PropertyName(ClassElementName));
+  // 2. ReturnIfAbrupt(propKey).
+  // 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,311 @@
+import { surroundingAgent } from '../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 Evaluator, type StatementEvaluator } from '../evaluator.mts';
+import {
+  Q, X,
+  Completion,
+  AbruptCompletion,
+  NormalCompletion,
+  ReturnIfAbrupt,
+  EnsureCompletion,
+  type ExpressionCompletion,
+  type PlainCompletion,
+} 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): Evaluator<PlainCompletion<void>> {
+  // 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[]) {
+  // 1. Let lref be the result of evaluating DestructuringAssignmentTarget.
+  const lref = yield* Evaluate(DestructuringAssignmentTarget);
+  // 2. ReturnIfAbrupt(lref).
+  ReturnIfAbrupt(lref);
+  // 3. Let restObj be OrdinaryObjectCreate(%Object.prototype%).
+  const restObj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  // 4. Perform ? CopyDataProperties(restObj, value, excludedNames).
+  Q(CopyDataProperties(restObj, value, excludedNames));
+  // 5. Return PutValue(lref, restObj).
+  return PutValue(lref, restObj);
+}
+
+function* PropertyDestructuringAssignmentEvaluation(AssignmentPropertyList: ParseNode.ObjectAssignmentPattern['AssignmentPropertyList'], value: Value): Evaluator<PlainCompletion<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(ResolveBinding(P, undefined, AssignmentProperty.IdentifierReference.strict));
+      // 3. Let v be ? GetV(value, P).
+      let v = Q(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 = yield* Evaluate(AssignmentProperty.Initializer);
+          // ii. Set v to ? GetValue(defaultValue)
+          v = Q(GetValue(defaultValue));
+        }
+      }
+      // 5. Perform ? PutValue(lref, v).
+      Q(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!);
+      // 2. ReturnIfAbrupt(name).
+      ReturnIfAbrupt(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 = yield* Evaluate(DestructuringAssignmentTarget);
+    // b. ReturnIfAbrupt(lref).
+    ReturnIfAbrupt(lref);
+  }
+  // 2. Let v be ? GetV(value, propertyName).
+  const v = Q(GetV(value, propertyName));
+  // 3. If Initializer is present and v is undefined, then
+  let rhsValue: ExpressionCompletion;
+  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 = yield* NamedEvaluation(Initializer as FunctionDeclaration, (lref as ReferenceRecord).ReferencedName as JSStringValue);
+    } else {
+      // i. Let defaultValue be the result of evaluating Initializer.
+      const defaultValue = yield* Evaluate(Initializer);
+      // ii. Let rhsValue be ? GetValue(defaultValue).
+      rhsValue = Q(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(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(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(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(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(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(IteratorStepValue(iteratorRecord));
+        // d. If next is not done, set value to next.
+        if (next !== 'done') {
+          value = next;
+        }
+      }
+      let v: ExpressionCompletion;
+      // 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 = yield* NamedEvaluation(Initializer as FunctionDeclaration, target);
+        } else { // b. Else,
+          // i. Let defaultValue be the result of evaluating Initializer.
+          const defaultValue = yield* Evaluate(Initializer);
+          // ii. Let v be ? GetValue(defaultValue).
+          v = Q(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(PutValue(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);
+        ReturnIfAbrupt(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(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(PutValue(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,61 @@
+import {
+  AbstractEqualityComparison,
+  GetValue,
+  IsStrictlyEqual,
+} from '../abstract-ops/all.mts';
+import { ReturnIfAbrupt, 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 = yield* Evaluate(EqualityExpression);
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(GetValue(lref));
+  // 3. Let rref be the result of evaluating RelationalExpression.
+  const rref = yield* Evaluate(RelationalExpression);
+  // 4. Let rval be ? GetValue(rref).
+  const rval = Q(GetValue(rref));
+  switch (operator) {
+    case '==':
+      // 5. Return the result of performing Abstract Equality Comparison rval == lval.
+      return AbstractEqualityComparison(rval, lval);
+    case '!=': {
+      // 5. Let r be the result of performing Abstract Equality Comparison rval == lval.
+      const r = AbstractEqualityComparison(rval, lval);
+      // 6. ReturnIfAbrupt(r).
+      ReturnIfAbrupt(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);
+  }
+}