@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/SwitchStatement.mts

@@ -0,0 +1,214 @@
+import { Evaluate, type PlainEvaluator, type StatementEvaluator } from '../evaluator.mts';
+import {
+  ReferenceRecord, Value,
+} from '../value.mts';
+import {
+  Completion,
+  AbruptCompletion,
+  NormalCompletion,
+  EnsureCompletion,
+  UpdateEmpty,
+  Q,
+} from '../completion.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  BlockDeclarationInstantiation,
+  Evaluate_StatementList,
+} from './all.mts';
+import {
+  surroundingAgent,
+  Assert, GetValue, IsStrictlyEqual, DeclarativeEnvironmentRecord,
+  X,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-caseclauseisselected */
+function* CaseClauseIsSelected(constructor: ParseNode.CaseClause, input: Value): PlainEvaluator<boolean> {
+  // 1. Assert: C is an instance of the production  CaseClause : `case` Expression `:` StatementList?.
+  Assert(constructor.type === 'CaseClause');
+  // 2. Let exprRef be the result of evaluating the Expression of C.
+  const exprRef = Q(yield* Evaluate(constructor.Expression));
+  // 3. Let clauseSelector be ? GetValue(exprRef).
+  const clauseSelector = Q(yield* GetValue(exprRef));
+  // 4. Return the result of performing Strict Equality Comparison input === clauseSelector.
+  return IsStrictlyEqual(input, clauseSelector);
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-caseblockevaluation */
+//   CaseBlock :
+//     `{` `}`
+//     `{` CaseClauses `}`
+//     `{` CaseClauses? DefaultClause CaseClauses? `}`
+function* CaseBlockEvaluation(node: ParseNode.CaseBlock, input: Value): StatementEvaluator {
+  const { CaseClauses_a, DefaultClause, CaseClauses_b } = node;
+  switch (true) {
+    case !CaseClauses_a && !DefaultClause && !CaseClauses_b: {
+      // 1. Return NormalCompletion(undefined).
+      return NormalCompletion(Value.undefined);
+    }
+    case !!CaseClauses_a && !DefaultClause && !CaseClauses_b: {
+      // 1. Let V be undefined.
+      let resultValue: Value = Value.undefined;
+      // 2. Let A be the List of CaseClause items in CaseClauses, in source text order.
+      const caseClauses = CaseClauses_a;
+      // 3. Let found be false.
+      let found = false;
+      // 4. For each CaseClause C in A, do
+      for (const clause of caseClauses) {
+        // a. If found is false, then
+        if (!found) {
+          // i. Set found to ? CaseClauseIsSelected(C, input).
+          found = Q(yield* CaseClauseIsSelected(clause, input));
+        }
+        // b. If found is true, them
+        if (found) {
+          // i. Let R be the result of evaluating C.
+          const completion = EnsureCompletion(yield* Evaluate(clause));
+          // ii. If R.[[Value]] is not empty, set V to R.[[Value]].
+          if (completion.Value !== undefined) {
+            resultValue = completion.Value;
+          }
+          // iii. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
+          if (completion instanceof AbruptCompletion) {
+            return Completion(UpdateEmpty(completion, resultValue));
+          }
+        }
+      }
+      // 5. Return NormalCompletion(V).
+      return NormalCompletion(resultValue);
+    }
+    case !!DefaultClause: {
+      // 1. Let V be undefined.
+      let resultValue: Value | ReferenceRecord = Value.undefined;
+      // 2. If the first CaseClauses is present, then
+      let caseClauses;
+      if (CaseClauses_a) {
+        // a. Let A be the List of CaseClause items in the first CaseClauses, in source text order.
+        caseClauses = CaseClauses_a;
+      } else { // 3. Else,
+        // a. Let A be « ».
+        caseClauses = [];
+      }
+      let found = false;
+      // 4. For each CaseClause C in A, do
+      for (const clause of caseClauses) {
+        // a. If found is false, then
+        if (!found) {
+          // i. Set found to ? CaseClauseIsSelected(C, input).
+          found = Q(yield* CaseClauseIsSelected(clause, input));
+        }
+        // b. If found is true, them
+        if (found) {
+          // i. Let R be the result of evaluating C.
+          const completion = EnsureCompletion(yield* Evaluate(clause));
+          // ii. If R.[[Value]] is not empty, set V to R.[[Value]].
+          if (completion.Value !== undefined) {
+            resultValue = completion.Value;
+          }
+          // iii. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
+          if (completion instanceof AbruptCompletion) {
+            return Completion(UpdateEmpty(completion, resultValue));
+          }
+        }
+      }
+      // 6. Let foundInB be false.
+      let foundInB = false;
+      // 7. If the second CaseClauses is present, then
+      let secondCaseClauses;
+      if (CaseClauses_b) {
+        // a. Let B be the List of CaseClause items in the second CaseClauses, in source text order.
+        secondCaseClauses = CaseClauses_b;
+      } else { // 8. Else,
+        // a. Let B be « ».
+        secondCaseClauses = [];
+      }
+      // 9. If found is false, then
+      if (!found) {
+        // a. For each CaseClause C in B, do
+        for (const clause of secondCaseClauses) {
+          // a. If foundInB is false, then
+          if (!foundInB) {
+            // i. Set foundInB to ? CaseClauseIsSelected(C, input).
+            foundInB = Q(yield* CaseClauseIsSelected(clause, input));
+          }
+          // b. If foundInB is true, them
+          if (foundInB) {
+            // i. Let R be the result of evaluating C.
+            const completion = EnsureCompletion(yield* Evaluate(clause));
+            // ii. If R.[[Value]] is not empty, set V to R.[[Value]].
+            if (completion.Value !== undefined) {
+              resultValue = completion.Value;
+            }
+            // iii. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
+            if (completion instanceof AbruptCompletion) {
+              return Completion(UpdateEmpty(completion, resultValue));
+            }
+          }
+        }
+      }
+      // 10. If foundInB is true, return NormalCompletion(V).
+      if (foundInB) {
+        return NormalCompletion(resultValue as Value);
+      }
+      // 11. Let R be the result of evaluating DefaultClause.
+      const completion = EnsureCompletion(yield* Evaluate(DefaultClause));
+      // 12. If R.[[Value]] is not empty, set V to R.[[Value]].
+      if (completion.Value !== undefined) {
+        resultValue = completion.Value;
+      }
+      // 13. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
+      if (completion instanceof AbruptCompletion) {
+        return Completion(UpdateEmpty(completion, resultValue));
+      }
+      // 14. NOTE: The following is another complete iteration of the second CaseClauses.
+      // 15. For each CaseClause C in B, do
+      for (const clause of secondCaseClauses) {
+        // a. Let R be the result of evaluating CaseClause C.
+        const innerR = EnsureCompletion(yield* Evaluate(clause));
+        // b. If R.[[Value]] is not empty, set V to R.[[Value]].
+        if (innerR.Value !== undefined) {
+          resultValue = innerR.Value;
+        }
+        // c. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
+        if (innerR instanceof AbruptCompletion) {
+          return Completion(UpdateEmpty(innerR, resultValue));
+        }
+      }
+      // 16. Return NormalCompletion(V).
+      //
+      return NormalCompletion(resultValue as Value);
+    }
+    default:
+      throw OutOfRange.nonExhaustive(node);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-switch-statement-runtime-semantics-evaluation */
+//   SwitchStatement :
+//     `switch` `(` Expression `)` CaseBlock
+export function* Evaluate_SwitchStatement({ Expression, CaseBlock }: ParseNode.SwitchStatement): StatementEvaluator {
+  const exprRef = Q(yield* Evaluate(Expression));
+  const switchValue = Q(yield* GetValue(exprRef));
+  const oldEnv = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  const blockEnv = new DeclarativeEnvironmentRecord(oldEnv);
+  X(BlockDeclarationInstantiation(CaseBlock, blockEnv));
+  surroundingAgent.runningExecutionContext.LexicalEnvironment = blockEnv;
+  const blockResult = yield* CaseBlockEvaluation(CaseBlock, switchValue);
+  Assert(blockEnv.DisposableResourceStack.length === 0);
+  surroundingAgent.runningExecutionContext.LexicalEnvironment = oldEnv;
+  return blockResult;
+}
+
+/** https://tc39.es/ecma262/#sec-switch-statement-runtime-semantics-evaluation */
+//   CaseClause :
+//     `case` Expression `:`
+//     `case` Expression `:` StatementList
+//   DefaultClause :
+//     `case` `default` `:`
+//     `case` `default` `:` StatementList
+export function* Evaluate_CaseClause({ StatementList }: ParseNode.CaseClause | ParseNode.DefaultClause) {
+  if (!StatementList) {
+    return NormalCompletion(undefined);
+  }
+  return yield* Evaluate_StatementList(StatementList);
+}

package/src/runtime-semantics/TaggedTemplateExpression.mts

@@ -0,0 +1,23 @@
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { IsInTailPosition } from '../static-semantics/all.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { EvaluateCall } from './all.mts';
+import { GetValue } from '#self';
+
+/** https://tc39.es/ecma262/#sec-tagged-templates-runtime-semantics-evaluation */
+//   MemberExpression :
+//     MemberExpression TemplateLiteral
+export function* Evaluate_TaggedTemplateExpression(node: ParseNode.TaggedTemplateExpression): ValueEvaluator {
+  const { MemberExpression, TemplateLiteral } = node;
+  // 1. Let tagRef be ? Evaluation of MemberExpression.
+  const tagRef = Q(yield* Evaluate(MemberExpression));
+  // 1. Let tagFunc be ? GetValue(tagRef).
+  const tagFunc = Q(yield* GetValue(tagRef));
+  // 1. Let thisCall be this MemberExpression.
+  const thisCall = node;
+  // 1. Let tailCall be IsInTailPosition(thisCall).
+  const tailCall = IsInTailPosition(thisCall);
+  // 1. Return ? EvaluateCall(tagFunc, tagRef, TemplateLiteral, tailCall).
+  return Q(yield* EvaluateCall(tagFunc, tagRef, TemplateLiteral, tailCall));
+}

package/src/runtime-semantics/TemplateLiteral.mts

@@ -0,0 +1,34 @@
+import { Value } from '../value.mts';
+import { Q } from '../completion.mts';
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { TV } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { GetValue, ToString } from '#self';
+
+/** https://tc39.es/ecma262/#sec-template-literals-runtime-semantics-evaluation */
+//   TemplateLiteral : NoSubstitutionTemplate
+//   SubstitutionTemplate : TemplateHead Expression TemplateSpans
+//   TemplateSpans : TemplateTail
+//   TemplateSpans : TemplateMiddleList TemplateTail
+//   TemplateMiddleList : TemplateMiddle Expression
+//   TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
+//
+// (implicit)
+//   TemplateLiteral : SubstitutionTemplate
+export function* Evaluate_TemplateLiteral({ TemplateSpanList, ExpressionList }: ParseNode.TemplateLiteral): ValueEvaluator {
+  let str = '';
+  for (let i = 0; i < TemplateSpanList.length - 1; i += 1) {
+    const Expression = ExpressionList[i];
+    const head = TV(TemplateSpanList[i]);
+    // 2. Let subRef be the result of evaluating Expression.
+    const subRef = Q(yield* Evaluate(Expression));
+    // 3. Let sub be ? GetValue(subRef).
+    const sub = Q(yield* GetValue(subRef));
+    // 4. Let middle be ? ToString(sub).
+    const middle = Q(yield* ToString(sub));
+    str += head;
+    str += middle.stringValue();
+  }
+  const tail = TV(TemplateSpanList[TemplateSpanList.length - 1]);
+  return Value(str + tail);
+}

package/src/runtime-semantics/This.mts

@@ -0,0 +1,9 @@
+import { Q, type ValueCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { ResolveThisBinding } from '#self';
+
+/** https://tc39.es/ecma262/#sec-this-keyword-runtime-semantics-evaluation */
+// PrimaryExpression : `this`
+export function Evaluate_This(_PrimaryExpression: ParseNode.ThisExpression): ValueCompletion {
+  return Q(ResolveThisBinding());
+}

package/src/runtime-semantics/ThrowStatement.mts

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

package/src/runtime-semantics/TrimString.mts

@@ -0,0 +1,19 @@
+import { JSStringValue, Value } from '../value.mts';
+import { Q, type ValueEvaluator } from '../completion.mts';
+import { Assert, RequireObjectCoercible, ToString } from '#self';
+
+/** https://tc39.es/ecma262/#sec-trimstring */
+export function* TrimString(string: Value, where: 'start' | 'end' | 'start+end'): ValueEvaluator<JSStringValue> {
+  Q(RequireObjectCoercible(string));
+  const S = Q(yield* ToString(string)).stringValue();
+  let T;
+  if (where === 'start') {
+    T = S.trimStart();
+  } else if (where === 'end') {
+    T = S.trimEnd();
+  } else {
+    Assert(where === 'start+end');
+    T = S.trim();
+  }
+  return Value(T);
+}

package/src/runtime-semantics/TryStatement.mts

@@ -0,0 +1,119 @@
+import { Value } from '../value.mts';
+import { Evaluate, type StatementEvaluator } from '../evaluator.mts';
+import {
+  Completion,
+  AbruptCompletion,
+  UpdateEmpty,
+  EnsureCompletion,
+  X,
+} from '../completion.mts';
+import { BoundNames } from '../static-semantics/all.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { BindingInitialization } from './all.mts';
+import { surroundingAgent, DeclarativeEnvironmentRecord } from '#self';
+
+/** https://tc39.es/ecma262/#sec-try-statement-runtime-semantics-evaluation */
+//   TryStatement :
+//     `try` Block Catch
+//     `try` Block Finally
+//     `try` Block Catch Finally
+export function Evaluate_TryStatement(TryStatement: ParseNode.TryStatement) {
+  switch (true) {
+    case !!TryStatement.Catch && !TryStatement.Finally:
+      return Evaluate_TryStatement_BlockCatch(TryStatement);
+    case !TryStatement.Catch && !!TryStatement.Finally:
+      return Evaluate_TryStatement_BlockFinally(TryStatement);
+    case !!TryStatement.Catch && !!TryStatement.Finally:
+      return Evaluate_TryStatement_BlockCatchFinally(TryStatement);
+    default:
+      throw OutOfRange.nonExhaustive(TryStatement);
+  }
+}
+
+// TryStatement : `try` Block Catch
+function* Evaluate_TryStatement_BlockCatch({ Block, Catch }: ParseNode.TryStatement) {
+  // 1. Let B be the result of evaluating Block.
+  const blockResult = EnsureCompletion(yield* Evaluate(Block));
+  // 2. If B.[[Type]] is throw, let C be CatchClauseEvaluation of Catch with argument B.[[Value]].
+  let catchResult;
+  if (blockResult.Type === 'throw') {
+    catchResult = EnsureCompletion(yield* CatchClauseEvaluation(Catch!, blockResult.Value));
+  } else { // 3. Else, let C be B.
+    catchResult = blockResult;
+  }
+  // 3. Return Completion(UpdateEmpty(C, undefined)).
+  return Completion(UpdateEmpty(catchResult, Value.undefined));
+}
+
+// TryStatement : `try` Block Finally
+function* Evaluate_TryStatement_BlockFinally({ Block, Finally }: ParseNode.TryStatement) {
+  // 1. Let B be the result of evaluating Block.
+  const blockResult = EnsureCompletion(yield* Evaluate(Block));
+  // 1. Let F be the result of evaluating Finally.
+  let finallyResult = EnsureCompletion(yield* Evaluate(Finally!));
+  // 1. If F.[[Type]] is normal, set F to B.
+  if (finallyResult.Type === 'normal') {
+    finallyResult = blockResult;
+  }
+  // 1. Return Completion(UpdateEmpty(F, undefined)).
+  return Completion(UpdateEmpty(finallyResult, Value.undefined));
+}
+
+// TryStatement : `try` Block Catch Finally
+function* Evaluate_TryStatement_BlockCatchFinally({ Block, Catch, Finally }: ParseNode.TryStatement) {
+  // 1. Let B be the result of evaluating Block.
+  const blockResult = EnsureCompletion(yield* Evaluate(Block));
+  // 2. If B.[[Type]] is throw, let C be CatchClauseEvaluation of Catch with argument B.[[Value]].
+  let catchResult: Completion<Value | void>;
+  if (blockResult.Type === 'throw') {
+    catchResult = EnsureCompletion(yield* CatchClauseEvaluation(Catch!, blockResult.Value));
+  } else { // 3. Else, let C be B.
+    catchResult = blockResult;
+  }
+  // 4. Let F be the result of evaluating Finally.
+  let finallyResult = EnsureCompletion(yield* Evaluate(Finally!));
+  // 5. If F.[[Type]] is normal, set F to C.
+  if (finallyResult.Type === 'normal') {
+    finallyResult = catchResult;
+  }
+  // 6. Return Completion(UpdateEmpty(F, undefined)).
+  return Completion(UpdateEmpty(finallyResult, Value.undefined));
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-catchclauseevaluation */
+//  Catch :
+//    `catch` Block
+//    `catch` `(` CatchParameter `)` Block
+function* CatchClauseEvaluation({ CatchParameter, Block }: ParseNode.Catch, thrownValue: Value): StatementEvaluator {
+  if (!CatchParameter) {
+    // 1. Return the result of evaluating Block.
+    return yield* Evaluate(Block);
+  }
+  // 1. Let oldEnv be the running execution context's LexicalEnvironment.
+  const oldEnv = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 2. Let catchEnv be NewDeclarativeEnvironment(oldEnv).
+  const catchEnv = new DeclarativeEnvironmentRecord(oldEnv);
+  // 3. For each element argName of the BoundNames of CatchParameter, do
+  for (const argName of BoundNames(CatchParameter)) {
+    // a. Perform ! catchEnv.CreateMutableBinding(argName, false).
+    X(catchEnv.CreateMutableBinding(argName, Value.false));
+  }
+  // 4. Set the running execution context's LexicalEnvironment to catchEnv.
+  surroundingAgent.runningExecutionContext.LexicalEnvironment = catchEnv;
+  // 5. Let status be BindingInitialization of CatchParameter with arguments thrownValue and catchEnv.
+  const status = yield* BindingInitialization(CatchParameter, thrownValue, catchEnv);
+  // 6. If status is an abrupt completion, then
+  if (status instanceof AbruptCompletion) {
+    // a. Set the running execution context's LexicalEnvironment to oldEnv.
+    surroundingAgent.runningExecutionContext.LexicalEnvironment = oldEnv;
+    // b. Return Completion(status).
+    return Completion(status);
+  }
+  // 7. Let B be the result of evaluating Block.
+  const blockCompletion = EnsureCompletion(yield* Evaluate(Block));
+  // 8. Set the running execution context's LexicalEnvironment to oldEnv.
+  surroundingAgent.runningExecutionContext.LexicalEnvironment = oldEnv;
+  // 9. Return Completion(B).
+  return Completion(blockCompletion);
+}

package/src/runtime-semantics/UnaryExpression.mts

@@ -0,0 +1,218 @@
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Q } from '../completion.mts';
+import {
+  Value, ReferenceRecord, UndefinedValue, BigIntValue, BooleanValue, JSStringValue, NullValue, NumberValue, ObjectValue, SymbolValue,
+} from '../value.mts';
+import { __ts_cast__, OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { surroundingAgent, EnvironmentRecord } from '#self';
+import {
+  Assert,
+  GetValue,
+  IsCallable,
+  IsPropertyReference,
+  IsSuperReference,
+  IsUnresolvableReference,
+  ToBoolean,
+  ToNumber,
+  ToObject,
+  ToNumeric,
+  type PropertyReference,
+  IsPropertyKey,
+  IsPrivateReference,
+  ToPropertyKey,
+  Throw,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-delete-operator-runtime-semantics-evaluation */
+//   UnaryExpression : `delete` UnaryExpression
+function* Evaluate_UnaryExpression_Delete({ UnaryExpression }: ParseNode.UnaryExpression) {
+  // 1. Let ref be the result of evaluating UnaryExpression.
+  const ref = Q(yield* Evaluate(UnaryExpression));
+  Q(ref);
+  // 3. If ref is not a Reference Record, return true.
+  if (!(ref instanceof ReferenceRecord)) {
+    return Value.true;
+  }
+  // 4. If IsUnresolvableReference(ref) is true, then
+  if (IsUnresolvableReference(ref) === Value.true) {
+    // a. Assert: ref.[[Strict]] is false.
+    Assert(ref.Strict === Value.false);
+    // b. Return true.
+    return Value.true;
+  }
+  // 5. If IsPropertyReference(ref) is true, then
+  if (IsPropertyReference(ref) === Value.true) {
+    __ts_cast__<PropertyReference>(ref);
+    // a. Assert: IsPrivateReference(ref) is false.
+    Assert(!IsPrivateReference(ref));
+    // b. If IsSuperReference(ref) is true, throw a ReferenceError exception.
+    if (IsSuperReference(ref) === Value.true) {
+      return Throw.ReferenceError('Cannot delete a super property');
+    }
+    // c. Let baseObj be ? ToObject(ref.[[Base]]).
+    const baseObj = Q(ToObject(ref.Base as Value));
+    // d. If ref.[[ReferencedName]] is not a property key, then
+    if (!IsPropertyKey(ref.ReferencedName)) {
+      // Set ref.[[ReferencedName]] to ? ToPropertyKey(ref.[[ReferencedName]]).
+      ref.ReferencedName = Q(yield* ToPropertyKey(ref.ReferencedName as Value));
+    }
+    // e. Let deleteStatus be ? baseObj.[[Delete]](ref.[[ReferencedName]]).
+    const deleteStatus = Q(yield* baseObj.Delete(ref.ReferencedName as JSStringValue));
+    // f. If deleteStatus is false and ref.[[Strict]] is true, throw a TypeError exception.
+    if (deleteStatus === Value.false && ref.Strict === Value.true) {
+      return Throw.TypeError('Cannot not delete property $1 on $2', ref.ReferencedName, baseObj);
+    }
+    // g. Return deleteStatus.
+    return deleteStatus;
+  } else { // 6. Else,
+    // a. Let base be ref.[[Base]].
+    const base = ref.Base;
+    // b. Assert: base is an Environment Record.
+    Assert(base instanceof EnvironmentRecord);
+    // c. Return ? bindings.DeleteBinding(GetReferencedName(ref)).
+    return Q(yield* base.DeleteBinding(ref.ReferencedName as JSStringValue));
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-void-operator-runtime-semantics-evaluation */
+//   UnaryExpression : `void` UnaryExpression
+function* Evaluate_UnaryExpression_Void({ UnaryExpression }: ParseNode.UnaryExpression): ValueEvaluator {
+  // 1. Let expr be the result of evaluating UnaryExpression.
+  const expr = Q(yield* Evaluate(UnaryExpression));
+  // 2. Perform ? GetValue(expr).
+  Q(yield* GetValue(expr));
+  // 3. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-typeof-operator-runtime-semantics-evaluation */
+// UnaryExpression : `typeof` UnaryExpression
+function* Evaluate_UnaryExpression_Typeof({ UnaryExpression }: ParseNode.UnaryExpression): ValueEvaluator {
+  // 1. Let val be the result of evaluating UnaryExpression.
+  const _val = Q(yield* Evaluate(UnaryExpression));
+  // 2. If Type(val) is Reference, then
+  if (_val instanceof ReferenceRecord) {
+    // a. If IsUnresolvableReference(val) is true, return "undefined".
+    if (IsUnresolvableReference(_val) === Value.true) {
+      return Value('undefined');
+    }
+  }
+  // 3. Set val to ? GetValue(val).
+  const val = Q(yield* GetValue(_val));
+  // 4. Return a String according to Table 37.
+  if (val instanceof UndefinedValue) {
+    return Value('undefined');
+  } else if (val instanceof NullValue) {
+    return Value('object');
+  } else if (val instanceof BooleanValue) {
+    return Value('boolean');
+  } else if (val instanceof NumberValue) {
+    return Value('number');
+  } else if (val instanceof JSStringValue) {
+    return Value('string');
+  } else if (val instanceof BigIntValue) {
+    return Value('bigint');
+  } else if (val instanceof SymbolValue) {
+    return Value('symbol');
+  } else if (val instanceof ObjectValue) {
+    if (IsCallable(val)) {
+      return Value('function');
+    }
+    return Value('object');
+  }
+  throw OutOfRange.exhaustive(val);
+}
+
+/** https://tc39.es/ecma262/#sec-unary-plus-operator-runtime-semantics-evaluation */
+//   UnaryExpression : `+` UnaryExpression
+function* Evaluate_UnaryExpression_Plus({ UnaryExpression }: ParseNode.UnaryExpression): ValueEvaluator {
+  // 1. Let expr be the result of evaluating UnaryExpression.
+  const expr = Q(yield* Evaluate(UnaryExpression));
+  // 2. Return ? ToNumber(? GetValue(expr)).
+  return Q(yield* ToNumber(Q(yield* GetValue(expr))));
+}
+
+/** https://tc39.es/ecma262/#sec-unary-minus-operator-runtime-semantics-evaluation */
+//   UnaryExpression : `-` UnaryExpression
+function* Evaluate_UnaryExpression_Minus({ UnaryExpression }: ParseNode.UnaryExpression): ValueEvaluator {
+  // 1. Let expr be the result of evaluating UnaryExpression.
+  const expr = Q(yield* Evaluate(UnaryExpression));
+  // 2. Let oldValue be ? ToNumeric(? GetValue(expr)).
+  const oldValue = Q(yield* ToNumeric(Q(yield* GetValue(expr))));
+  // 3. If oldValue is a Number, then
+  if (oldValue instanceof NumberValue) {
+    // a. Return Number::unaryMinus(oldValue).
+    return NumberValue.unaryMinus(oldValue);
+  } else {
+    // a. Assert: oldValue is a BigInt.
+    // b. Return BigInt::unaryMinus(oldValue).
+    Assert(oldValue instanceof BigIntValue);
+    return BigIntValue.unaryMinus(oldValue);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-bitwise-not-operator-runtime-semantics-evaluation */
+//   UnaryExpression : `~` UnaryExpression
+function* Evaluate_UnaryExpression_Tilde({ UnaryExpression }: ParseNode.UnaryExpression): ValueEvaluator {
+  // 1. Let expr be the result of evaluating UnaryExpression.
+  const expr = Q(yield* Evaluate(UnaryExpression));
+  // 2. Let oldValue be ? ToNumeric(? GetValue(expr)).
+  const oldValue = Q(yield* ToNumeric(Q(yield* GetValue(expr))));
+  // 3. If oldValue is a Number, then
+  if (oldValue instanceof NumberValue) {
+    // a. Return Number::bitwiseNOT(oldValue).
+    return NumberValue.bitwiseNOT(oldValue);
+  } else {
+    // a. Assert: oldValue is a BigInt.
+    // b. Return BigInt::bitwiseNOT(oldValue).
+    Assert(oldValue instanceof BigIntValue);
+    return BigIntValue.bitwiseNOT(oldValue);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-logical-not-operator-runtime-semantics-evaluation */
+//   UnaryExpression : `!` UnaryExpression
+function* Evaluate_UnaryExpression_Bang({ UnaryExpression }: ParseNode.UnaryExpression): ValueEvaluator {
+  // 1. Let expr be the result of evaluating UnaryExpression.
+  const expr = Q(yield* Evaluate(UnaryExpression));
+  // 2. Let oldValue be ! ToBoolean(? GetValue(expr)).
+  const oldValue = ToBoolean(Q(yield* GetValue(expr)));
+  // 3. If oldValue is true, return false.
+  if (oldValue === Value.true) {
+    return Value.false;
+  }
+  // 4. Return true.
+  return Value.true;
+}
+
+// UnaryExpression :
+//  `delete` UnaryExpression
+//  `void` UnaryExpression
+//  `typeof` UnaryExpression
+//  `+` UnaryExpression
+//  `-` UnaryExpression
+//  `~` UnaryExpression
+//  `!` UnaryExpression
+export function* Evaluate_UnaryExpression(UnaryExpression: ParseNode.UnaryExpression) {
+  switch (UnaryExpression.operator) {
+    case 'delete':
+      Q(surroundingAgent.debugger_cannotPreview);
+      return yield* Evaluate_UnaryExpression_Delete(UnaryExpression);
+    case 'void':
+      return yield* Evaluate_UnaryExpression_Void(UnaryExpression);
+    case 'typeof':
+      return yield* Evaluate_UnaryExpression_Typeof(UnaryExpression);
+    case '+':
+      return yield* Evaluate_UnaryExpression_Plus(UnaryExpression);
+    case '-':
+      return yield* Evaluate_UnaryExpression_Minus(UnaryExpression);
+    case '~':
+      return yield* Evaluate_UnaryExpression_Tilde(UnaryExpression);
+    case '!':
+      return yield* Evaluate_UnaryExpression_Bang(UnaryExpression);
+
+    default:
+      throw OutOfRange.nonExhaustive(UnaryExpression);
+  }
+}