@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/Unicode.mts

@@ -0,0 +1,268 @@
+import unicodeCaseFoldingCommon from '@unicode/unicode-17.0.0/Case_Folding/C/symbols.js';
+import unicodeCaseFoldingSimple from '@unicode/unicode-17.0.0/Case_Folding/S/symbols.js';
+// @ts-ignore
+import UnicodeSets from '../unicode/CodePointProperties.json' with { type: 'json' };
+// @ts-ignore
+import SequenceProperties from '../unicode/SequenceProperties.json' with { type: 'json' };
+import { Assert, Canonicalize, type RegExpRecord } from '#self';
+
+export const isLeadingSurrogate = (cp: number) => cp >= 0xD800 && cp <= 0xDBFF;
+export const isTrailingSurrogate = (cp: number) => cp >= 0xDC00 && cp <= 0xDFFF;
+/** https://tc39.es/ecma262/#table-nonbinary-unicode-properties */
+export const Table69_NonbinaryUnicodeProperties = {
+  General_Category: 'General_Category',
+  gc: 'General_Category',
+  Script: 'Script',
+  sc: 'Script',
+  Script_Extensions: 'Script_Extensions',
+  scx: 'Script_Extensions',
+} as const;
+Object.setPrototypeOf(Table69_NonbinaryUnicodeProperties, null);
+export type Table69_NonbinaryUnicodePropertiesCanonicalized = typeof Table69_NonbinaryUnicodeProperties[keyof typeof Table69_NonbinaryUnicodeProperties];
+
+/** https://tc39.es/ecma262/#table-binary-unicode-properties */
+export const Table70_BinaryUnicodeProperties = {
+  ASCII: 'ASCII',
+  ASCII_Hex_Digit: 'ASCII_Hex_Digit',
+  AHex: 'ASCII_Hex_Digit',
+  Alphabetic: 'Alphabetic',
+  Alpha: 'Alphabetic',
+  Any: 'Any',
+  Assigned: 'Assigned',
+  Bidi_Control: 'Bidi_Control',
+  Bidi_C: 'Bidi_Control',
+  Bidi_Mirrored: 'Bidi_Mirrored',
+  Bidi_M: 'Bidi_Mirrored',
+  Case_Ignorable: 'Case_Ignorable',
+  CI: 'Case_Ignorable',
+  Cased: 'Cased',
+  Changes_When_Casefolded: 'Changes_When_Casefolded',
+  CWCF: 'Changes_When_Casefolded',
+  Changes_When_Casemapped: 'Changes_When_Casemapped',
+  CWCM: 'Changes_When_Casemapped',
+  Changes_When_Lowercased: 'Changes_When_Lowercased',
+  CWL: 'Changes_When_Lowercased',
+  Changes_When_NFKC_Casefolded: 'Changes_When_NFKC_Casefolded',
+  CWKCF: 'Changes_When_NFKC_Casefolded',
+  Changes_When_Titlecased: 'Changes_When_Titlecased',
+  CWT: 'Changes_When_Titlecased',
+  Changes_When_Uppercased: 'Changes_When_Uppercased',
+  CWU: 'Changes_When_Uppercased',
+  Dash: 'Dash',
+  Default_Ignorable_Code_Point: 'Default_Ignorable_Code_Point',
+  DI: 'Default_Ignorable_Code_Point',
+  Deprecated: 'Deprecated',
+  Dep: 'Deprecated',
+  Diacritic: 'Diacritic',
+  Dia: 'Diacritic',
+  Emoji: 'Emoji',
+  Emoji_Component: 'Emoji_Component',
+  EComp: 'Emoji_Component',
+  Emoji_Modifier: 'Emoji_Modifier',
+  EMod: 'Emoji_Modifier',
+  Emoji_Modifier_Base: 'Emoji_Modifier_Base',
+  EBase: 'Emoji_Modifier_Base',
+  Emoji_Presentation: 'Emoji_Presentation',
+  EPres: 'Emoji_Presentation',
+  Extended_Pictographic: 'Extended_Pictographic',
+  ExtPict: 'Extended_Pictographic',
+  Extender: 'Extender',
+  Ext: 'Extender',
+  Grapheme_Base: 'Grapheme_Base',
+  Gr_Base: 'Grapheme_Base',
+  Grapheme_Extend: 'Grapheme_Extend',
+  Gr_Ext: 'Grapheme_Extend',
+  Hex_Digit: 'Hex_Digit',
+  Hex: 'Hex_Digit',
+  IDS_Binary_Operator: 'IDS_Binary_Operator',
+  IDSB: 'IDS_Binary_Operator',
+  IDS_Trinary_Operator: 'IDS_Trinary_Operator',
+  IDST: 'IDS_Trinary_Operator',
+  ID_Continue: 'ID_Continue',
+  IDC: 'ID_Continue',
+  ID_Start: 'ID_Start',
+  IDS: 'ID_Start',
+  Ideographic: 'Ideographic',
+  Ideo: 'Ideographic',
+  Join_Control: 'Join_Control',
+  Join_C: 'Join_Control',
+  Logical_Order_Exception: 'Logical_Order_Exception',
+  LOE: 'Logical_Order_Exception',
+  Lowercase: 'Lowercase',
+  Lower: 'Lowercase',
+  Math: 'Math',
+  Noncharacter_Code_Point: 'Noncharacter_Code_Point',
+  NChar: 'Noncharacter_Code_Point',
+  Pattern_Syntax: 'Pattern_Syntax',
+  Pat_Syn: 'Pattern_Syntax',
+  Pattern_White_Space: 'Pattern_White_Space',
+  Pat_WS: 'Pattern_White_Space',
+  Quotation_Mark: 'Quotation_Mark',
+  QMark: 'Quotation_Mark',
+  Radical: 'Radical',
+  Regional_Indicator: 'Regional_Indicator',
+  RI: 'Regional_Indicator',
+  Sentence_Terminal: 'Sentence_Terminal',
+  STerm: 'Sentence_Terminal',
+  Soft_Dotted: 'Soft_Dotted',
+  SD: 'Soft_Dotted',
+  Terminal_Punctuation: 'Terminal_Punctuation',
+  Term: 'Terminal_Punctuation',
+  Unified_Ideograph: 'Unified_Ideograph',
+  UIdeo: 'Unified_Ideograph',
+  Uppercase: 'Uppercase',
+  Upper: 'Uppercase',
+  Variation_Selector: 'Variation_Selector',
+  VS: 'Variation_Selector',
+  White_Space: 'White_Space',
+  space: 'White_Space',
+  XID_Continue: 'XID_Continue',
+  XIDC: 'XID_Continue',
+  XID_Start: 'XID_Start',
+  XIDS: 'XID_Start',
+} as const;
+Object.setPrototypeOf(Table70_BinaryUnicodeProperties, null);
+
+/** https://tc39.es/ecma262/#table-binary-unicode-properties-of-strings */
+export const Table71_BinaryPropertyOfStrings = {
+  Basic_Emoji: 'Basic_Emoji',
+  Emoji_Keycap_Sequence: 'Emoji_Keycap_Sequence',
+  RGI_Emoji_Modifier_Sequence: 'RGI_Emoji_Modifier_Sequence',
+  RGI_Emoji_Flag_Sequence: 'RGI_Emoji_Flag_Sequence',
+  RGI_Emoji_Tag_Sequence: 'RGI_Emoji_Tag_Sequence',
+  RGI_Emoji_ZWJ_Sequence: 'RGI_Emoji_ZWJ_Sequence',
+  RGI_Emoji: 'RGI_Emoji',
+} as const;
+Object.setPrototypeOf(Table71_BinaryPropertyOfStrings, null);
+
+const canonicalizeUnicodePropertyCache: Record<string, [excludeSet: ReadonlySet<string>, includeSet: ReadonlySet<string>]> = { __proto__: null! };
+const stringPropertySetCache: Record<string, readonly ListOfCharacter[]> = {};
+// TODO(unicode): methods here should be implemented based on Unicode database so we can pin Unicode version.
+export const Unicode = {
+  toUppercase(ch: CodePoint): ListOfCharacter {
+    return String.fromCodePoint(ch).toUpperCase() as ListOfCharacter;
+  },
+  toCodePoint(ch: Character): CodePoint {
+    return ch.codePointAt(0)! as CodePoint;
+  },
+  toCharacter(ch: CodePoint): UnicodeCharacter {
+    return String.fromCodePoint(ch) as UnicodeCharacter;
+  },
+  isCharacter(ch: Character | ListOfCharacter): ch is Character {
+    return ch.length === 1 || [...ch].length === 1;
+  },
+  toCodeUnit(ch: Character): [CodeUnit, CodeUnit?] {
+    const codePoint = ch.charCodeAt(0)!;
+    const codePoint2 = ch.charCodeAt(1);
+    return [codePoint as CodeUnit, Number.isNaN(codePoint2) ? codePoint2 as CodeUnit : undefined];
+  },
+  iterateByCodePoint(x: string): UnicodeCharacter[] {
+    return Array.from(x) as UnicodeCharacter[];
+  },
+  characterMatchPropertyValue(ch: Character | ListOfCharacter, property: Table69_NonbinaryUnicodePropertiesCanonicalized, value: string | undefined, rer: RegExpRecord | undefined) {
+    if (!Unicode.isCharacter(ch)) {
+      return false;
+    }
+    let path = value ? `${property}/${value}` : `Binary_Property/${property}`;
+    const cp = ch.codePointAt(0)!;
+    // https://www.unicode.org/reports/tr24/#Script_Values
+    // Unknown is: Unused, private use or surrogate code points.
+    if ((property === 'Script' || property === 'Script_Extensions') && (value === 'Unknown' || value === 'Zzzz')) {
+      // https://www.unicode.org/faq/private_use.html
+      if ((cp >= 0xE000 && cp <= 0xF8FF) || (cp >= 0xF0000 && cp <= 0xFFFFD) || (cp >= 0x100000 && cp <= 0x10FFFD)) {
+        return true;
+      }
+      // Non characters
+      if ((cp >= 0xFDD0 && cp <= 0xFDEF) || cp === 0xFFFE || cp === 0xFFFF || cp.toString(16).match(/^(?:[0-9a-f]|10)fff[fe]$/i)) {
+        return true;
+      }
+      if (isLeadingSurrogate(cp) || isTrailingSurrogate(cp)) {
+        return true;
+      }
+      path = 'General_Category/Unassigned';
+    }
+    if (!(path in UnicodeSets)) {
+      throw new Assert.Error(`Unicode property "${path}" not found in UnicodeSets.`);
+    }
+    if (rer) {
+      const cacheKey = JSON.stringify([rer, path]);
+      if (!canonicalizeUnicodePropertyCache[cacheKey]) {
+        const excludeSet = new Set<string>();
+        const includeSet = new Set<string>();
+        for (const [from, to] of (UnicodeSets as Record<string, number[][]>)[path]) {
+          for (let index = from; index <= to; index += 1) {
+            const char = String.fromCodePoint(index) as UnicodeCharacter;
+            const ch2 = Canonicalize(rer, char) as UnicodeCharacter;
+            if (char !== ch2) {
+              excludeSet.add(char);
+              includeSet.add(ch2);
+            }
+          }
+        }
+        canonicalizeUnicodePropertyCache[cacheKey] = [excludeSet, includeSet];
+      }
+      const [excludeSet, includeSet] = canonicalizeUnicodePropertyCache[cacheKey];
+      if (excludeSet.has(ch)) {
+        return false;
+      }
+      if (includeSet.has(ch)) {
+        return true;
+      }
+    }
+    return !!(UnicodeSets as Record<string, number[][]>)[path].find(([from, to]) => from <= cp && cp <= to);
+  },
+  getStringPropertySet(property: keyof typeof Table71_BinaryPropertyOfStrings) {
+    stringPropertySetCache[property] ??= SequenceProperties[property].split(',') as ListOfCharacter[];
+    return stringPropertySetCache[property];
+  },
+
+  /** https://www.unicode.org/reports/tr44/#Simple_Case_Folding */
+  // TODO: scf() in spec means Simple Case Folding or Simple + Common Case Folding?
+  // https://github.com/tc39/ecma262/issues/3594
+  // SimpleCaseFoldingMapping(ch: Character): Character {
+  //   // Note: The case foldings are omitted in the data file if they are the same as the code point itself.
+  //   return (unicodeCaseFoldingSimple.get(ch) || ch) as Character;
+  // },
+  SimpleOrCommonCaseFoldingMapping(ch: Character): Character | undefined {
+    if (unicodeCaseFoldingCommon.has(ch)) {
+      return unicodeCaseFoldingCommon.get(ch)! as Character;
+    }
+    if (unicodeCaseFoldingSimple.has(ch)) {
+      return unicodeCaseFoldingSimple.get(ch)! as Character;
+    }
+    return ch;
+  },
+  iterateCharacterByCodePoint(string: Character | ListOfCharacter) {
+    return string[Symbol.iterator]() as IterableIterator<Character>;
+  },
+  str_normalization(string: string, form: 'NFC' | 'NFD' | 'NFKC' | 'NFKD'): string {
+    return string.normalize(form);
+  },
+  str_toLowercase(string: string): string {
+    return string.toLowerCase();
+  },
+  str_toUppercase(string: string): string {
+    return string.toUpperCase();
+  },
+  str_toLocaleLowercase(string: string): string {
+    return string.toLocaleLowerCase();
+  },
+  str_toLocaleUppercase(string: string): string {
+    return string.toLocaleUpperCase();
+  },
+};
+
+/** https://tc39.es/ecma262/#sec-pattern-semantics */
+export type BMPCharacter = string & { description: 'A code unit', length: 1 };
+/** https://tc39.es/ecma262/#sec-pattern-semantics */
+export type UnicodeCharacter = string & { description: 'A code point', length: 1 | 2 };
+/** https://tc39.es/ecma262/#sec-pattern-semantics */
+export type Character = BMPCharacter | UnicodeCharacter;
+/* List of BMPCharacter (non Unicode mode) or list of CodePoint. */
+export type ListOfCharacter = string & { __brand__: 'ListOfCharacter' };
+
+/** https://developer.mozilla.org/en-US/docs/Glossary/Code_point */
+export type CodePoint = number & { __brand__: 'CodePoint' };
+
+/** https://developer.mozilla.org/en-US/docs/Glossary/Code_unit */
+export type CodeUnit = number & { __brand__: 'CodeUnit' };

package/src/runtime-semantics/UpdateExpression.mts

@@ -0,0 +1,126 @@
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { OutOfRange } from '../utils/language.mts';
+import { BigIntValue, NumberValue } from '../value.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Assert,
+  F,
+  GetValue,
+  PutValue,
+  ToNumeric,
+  Z,
+} from '#self';
+
+type AnyNumericValue = BigIntValue | NumberValue;
+// UpdateExpression :
+//   LeftHandSideExpression `++`
+//   LeftHandSideExpression `--`
+//   `++` UnaryExpression
+//   `--` UnaryExpression
+export function* Evaluate_UpdateExpression({ LeftHandSideExpression, operator, UnaryExpression }: ParseNode.UpdateExpression): ValueEvaluator {
+  switch (true) {
+    // UpdateExpression : LeftHandSideExpression `++`
+    // https://tc39.es/ecma262/#sec-postfix-increment-operator-runtime-semantics-evaluation
+    case operator === '++' && !!LeftHandSideExpression: {
+      // 1. Let lhs be the result of evaluating LeftHandSideExpression.
+      const lhs = Q(yield* Evaluate(LeftHandSideExpression));
+      // 2. Let oldValue be ? ToNumeric(? GetValue(lhs)).
+      const oldValue = Q(yield* ToNumeric(Q(yield* GetValue(lhs))));
+      // 3. If oldValue is a Number, then
+      //  a. Let newValue be Number::add(oldValue, 1𝔽).
+      //  4. Else,
+      //         a. Assert: oldValue is a BigInt.
+      //         b. Let newValue be BigInt::add(oldValue, 1ℤ).
+      let newValue: AnyNumericValue;
+      if (oldValue instanceof NumberValue) {
+        newValue = NumberValue.add(oldValue, F(1));
+      } else {
+        Assert(oldValue instanceof BigIntValue);
+        newValue = BigIntValue.add(oldValue, Z(1n));
+      }
+      // 4. Perform ? PutValue(lhs, newValue).
+      Q(yield* PutValue(lhs, newValue));
+      // 5. Return oldValue.
+      return oldValue;
+    }
+
+    // UpdateExpression : LeftHandSideExpression `--`
+    // https://tc39.es/ecma262/#sec-postfix-decrement-operator-runtime-semantics-evaluation
+    case operator === '--' && !!LeftHandSideExpression: {
+      // 1. Let lhs be the result of evaluating LeftHandSideExpression.
+      const lhs = Q(yield* Evaluate(LeftHandSideExpression));
+      // 2. Let oldValue be ? ToNumeric(? GetValue(lhs)).
+      const oldValue = Q(yield* ToNumeric(Q(yield* GetValue(lhs))));
+      // 3. If oldValue is a Number, then
+      //  a. Let newValue be Number::subtract(oldValue, 1𝔽).
+      //  4. Else,
+      //         a. Assert: oldValue is a BigInt.
+      //         b. Let newValue be BigInt::subtract(oldValue, 1ℤ).
+      let newValue: AnyNumericValue;
+      if (oldValue instanceof NumberValue) {
+        newValue = NumberValue.subtract(oldValue, F(1));
+      } else {
+        Assert(oldValue instanceof BigIntValue);
+        newValue = BigIntValue.subtract(oldValue, Z(1n));
+      }
+      // 4. Perform ? PutValue(lhs, newValue).
+      Q(yield* PutValue(lhs, newValue));
+      // 5. Return oldValue.
+      return oldValue;
+    }
+
+    // UpdateExpression : `++` UnaryExpression
+    // https://tc39.es/ecma262/#sec-prefix-increment-operator-runtime-semantics-evaluation
+    case operator === '++' && !!UnaryExpression: {
+      // 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
+      //  a. Let newValue be Number::add(oldValue, 1𝔽).
+      //  4. Else,
+      //         a. Assert: oldValue is a BigInt.
+      //         b. Let newValue be BigInt::add(oldValue, 1ℤ).
+      let newValue: AnyNumericValue;
+      if (oldValue instanceof NumberValue) {
+        newValue = NumberValue.add(oldValue, F(1));
+      } else {
+        Assert(oldValue instanceof BigIntValue);
+        newValue = BigIntValue.add(oldValue, Z(1n));
+      }
+      // 4. Perform ? PutValue(expr, newValue).
+      Q(yield* PutValue(expr, newValue));
+      // 5. Return newValue.
+      return newValue;
+    }
+
+    // UpdateExpression : `--` UnaryExpression
+    // https://tc39.es/ecma262/#sec-prefix-decrement-operator-runtime-semantics-evaluation
+    case operator === '--' && !!UnaryExpression: {
+      // 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
+      //   a. Let newValue be Number::subtract(oldValue, 1𝔽).
+      // 4. Else,
+      //   a. Assert: oldValue is a BigInt.
+      //   b. Let newValue be BigInt::subtract(oldValue, 1ℤ).
+      let newValue: AnyNumericValue;
+      if (oldValue instanceof NumberValue) {
+        newValue = NumberValue.subtract(oldValue, F(1));
+      } else {
+        Assert(oldValue instanceof BigIntValue);
+        newValue = BigIntValue.subtract(oldValue, Z(1n));
+      }
+      // 4. Perform ? PutValue(expr, newValue).
+      Q(yield* PutValue(expr, newValue));
+      // 5. Return newValue.
+      return newValue;
+    }
+
+    default:
+      throw OutOfRange.nonExhaustive(operator);
+  }
+}

package/src/runtime-semantics/VariableStatement.mts

@@ -0,0 +1,72 @@
+import {
+  NormalCompletion, Q,
+} from '../completion.mts';
+import { Evaluate, type PlainEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { StringValue, IsAnonymousFunctionDefinition, type FunctionDeclaration } from '../static-semantics/all.mts';
+import { Value } from '../value.mts';
+import { NamedEvaluation, BindingInitialization } from './all.mts';
+import {
+  GetValue,
+  PutValue,
+  ResolveBinding,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-variable-statement-runtime-semantics-evaluation */
+//   VariableDeclaration :
+//     BindingIdentifier
+//     BindingIdentifier Initializer
+//     BindingPattern Initializer
+function* Evaluate_VariableDeclaration({ BindingIdentifier, Initializer, BindingPattern }: ParseNode.VariableDeclaration): PlainEvaluator {
+  if (BindingIdentifier) {
+    if (!Initializer) {
+      // 1. Return NormalCompletion(empty).
+      return NormalCompletion(undefined);
+    }
+    // 1. Let bindingId be StringValue of BindingIdentifier.
+    const bindingId = StringValue(BindingIdentifier);
+    // 2. Let lhs be ? ResolveBinding(bindingId).
+    const lhs = Q(yield* ResolveBinding(bindingId, undefined, BindingIdentifier.strict));
+    // 3. If IsAnonymousFunctionDefinition(Initializer) is true, then
+    let value;
+    if (IsAnonymousFunctionDefinition(Initializer)) {
+      // a. Let value be NamedEvaluation of Initializer with argument bindingId.
+      value = Q(yield* NamedEvaluation(Initializer as FunctionDeclaration, bindingId));
+    } else { // 4. Else,
+      // a. Let rhs be the result of evaluating Initializer.
+      const rhs = Q(yield* Evaluate(Initializer));
+      // b. Let value be ? GetValue(rhs).
+      value = Q(yield* GetValue(rhs));
+    }
+    // 5. Return ? PutValue(lhs, value).
+    return Q(yield* PutValue(lhs, value));
+  }
+  // 1. Let rhs be the result of evaluating Initializer.
+  const rhs = Q(yield* Evaluate(Initializer!));
+  // 2. Let rval be ? GetValue(rhs).
+  const rval = Q(yield* GetValue(rhs));
+  // 3. Return the result of performing BindingInitialization for BindingPattern passing rval and undefined as arguments.
+  return yield* BindingInitialization(BindingPattern!, rval, Value.undefined);
+}
+
+/** https://tc39.es/ecma262/#sec-variable-statement-runtime-semantics-evaluation */
+//   VariableDeclarationList : VariableDeclarationList `,` VariableDeclaration
+//
+// (implicit)
+//   VariableDeclarationList : VariableDeclaration
+export function* Evaluate_VariableDeclarationList(VariableDeclarationList: ParseNode.VariableDeclarationList) {
+  let next;
+  for (const VariableDeclaration of VariableDeclarationList) {
+    next = yield* Evaluate_VariableDeclaration(VariableDeclaration);
+    Q(next);
+  }
+  return next;
+}
+
+/** https://tc39.es/ecma262/#sec-variable-statement-runtime-semantics-evaluation */
+//   VariableStatement : `var` VariableDeclarationList `;`
+export function* Evaluate_VariableStatement({ VariableDeclarationList }: ParseNode.VariableStatement): PlainEvaluator {
+  const next = yield* Evaluate_VariableDeclarationList(VariableDeclarationList);
+  Q(next);
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/WithStatement.mts

@@ -0,0 +1,33 @@
+import { Value } from '../value.mts';
+import { Evaluate } from '../evaluator.mts';
+import {
+  UpdateEmpty,
+  Completion,
+  EnsureCompletion,
+  Q,
+} from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  surroundingAgent, ToObject, GetValue, ObjectEnvironmentRecord,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-with-statement-runtime-semantics-evaluation */
+//   WithStatement : `with` `(` Expression `)` Statement
+export function* Evaluate_WithStatement({ Expression, Statement }: ParseNode.WithStatement) {
+  // 1. Let val be the result of evaluating Expression.
+  const val = Q(yield* Evaluate(Expression));
+  // 2. Let obj be ? ToObject(? GetValue(val)).
+  const obj = Q(ToObject(Q(yield* GetValue(val))));
+  // 3. Let oldEnv be the running execution context's LexicalEnvironment.
+  const oldEnv = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 4. Let newEnv be NewObjectEnvironment(obj, true, oldEnv).
+  const newEnv = new ObjectEnvironmentRecord(obj, Value.true, oldEnv);
+  // 5. Set the running execution context's LexicalEnvironment to newEnv.
+  surroundingAgent.runningExecutionContext.LexicalEnvironment = newEnv;
+  // 6. Let C be the result of evaluating Statement.
+  const stmtCompletion = EnsureCompletion(yield* Evaluate(Statement));
+  // 7. Set the running execution context's LexicalEnvironment to oldEnv.
+  surroundingAgent.runningExecutionContext.LexicalEnvironment = oldEnv;
+  // 8. Return Completion(UpdateEmpty(C, undefined)).
+  return Completion(UpdateEmpty(stmtCompletion, Value.undefined));
+}

package/src/runtime-semantics/YieldExpression.mts

@@ -0,0 +1,175 @@
+import { ObjectValue, Value } from '../value.mts';
+import {
+  Await,
+  NormalCompletion,
+  Q,
+  ReturnCompletion,
+  ThrowCompletion,
+  type ValueCompletion,
+} from '../completion.mts';
+import { Evaluate, type YieldEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Assert,
+  Call,
+  EnsureCompletion,
+  GeneratorYield,
+  GetGeneratorKind,
+  GetIterator,
+  GetMethod,
+  GetValue,
+  IteratorClose,
+  IteratorComplete,
+  IteratorValue,
+  AsyncGeneratorYield,
+  AsyncIteratorClose,
+  Throw,
+  Yield,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluation */
+//   YieldExpression :
+//     `yield`
+//     `yield` AssignmentExpression
+//     `yield` `*` AssignmentExpression
+export function* Evaluate_YieldExpression({ hasStar, AssignmentExpression }: ParseNode.YieldExpression): YieldEvaluator {
+  if (hasStar) {
+    // 1. Let generatorKind be GetGeneratorKind().
+    const generatorKind = GetGeneratorKind();
+    // 2. Assert: generatorKind is either sync or async.
+    Assert(generatorKind === 'async' || generatorKind === 'sync');
+    // 2. Let exprRef be ? Evaluation of AssignmentExpression.
+    const exprRef = Q(yield* Evaluate(AssignmentExpression!));
+    // 3. Let value be ? GetValue(exprRef).
+    const value = Q(yield* GetValue(exprRef));
+    // 4. Let iteratorRecord be ? GetIterator(value, generatorKind).
+    const iteratorRecord = Q(yield* GetIterator(value, generatorKind));
+    // 5. Let iterator be iteratorRecord.[[Iterator]].
+    const iterator = iteratorRecord.Iterator;
+    // 6. Let received be NormalCompletion(undefined).
+    let received: ValueCompletion | ReturnCompletion = NormalCompletion(Value.undefined);
+    // 7. Repeat,
+    while (true) {
+      // a. If received is a normal completion, then
+      if (received instanceof NormalCompletion) {
+        // i. Let innerResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « received.[[Value]] »).
+        let innerResult: Value = Q(yield* Call(iteratorRecord.NextMethod, iteratorRecord.Iterator, [received.Value]));
+        // ii. If generatorKind is async, then set innerResult to ? Await(innerResult).
+        if (generatorKind === 'async') {
+          innerResult = Q(yield* Await(innerResult));
+        }
+        // iii. If Type(innerResult) is not Object, throw a TypeError exception.
+        if (!(innerResult instanceof ObjectValue)) {
+          return Throw.TypeError('The return value ($1) of the next() on an iterator ($2) must be an object', innerResult, iterator);
+        }
+        // iv. Let done be ? IteratorComplete(innerResult).
+        const done = Q(yield* IteratorComplete(innerResult));
+        // v. If done is true, then
+        if (done === Value.true) {
+          // 1. Return ? IteratorValue(innerResult).
+          return Q(yield* IteratorValue(innerResult));
+        }
+        // vi. If generatorKind is async, then set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
+        if (generatorKind === 'async') {
+          received = EnsureCompletion(yield* AsyncGeneratorYield(Q(yield* IteratorValue(innerResult))));
+        } else { // vii. Else, set received to GeneratorYield(innerResult).
+          received = EnsureCompletion(yield* GeneratorYield(innerResult));
+        }
+      } else if (received instanceof ThrowCompletion) { // b. Else if received is a throw completion, then
+        // i. Let throw be ? GetMethod(iterator, "throw").
+        const thr = Q(yield* GetMethod(iterator, Value('throw')));
+        // ii. If throw is not undefined, then
+        if (thr !== Value.undefined) {
+          // 1. Let innerResult be ? Call(throw, iterator, « received.[[Value]] »).
+          let innerResult: Value = Q(yield* Call(thr, iterator, [received.Value]));
+          // 2. If generatorKind is async, then set innerResult to ? Await(innerResult).
+          if (generatorKind === 'async') {
+            innerResult = Q(yield* Await(innerResult));
+          }
+          // 3. NOTE: Exceptions from the inner iterator throw method are propagated. Normal completions from an inner throw method are processed similarly to an inner next.
+          // 4. If Type(innerResult) is not Object, throw a TypeError exception.
+          if (!(innerResult instanceof ObjectValue)) {
+            return Throw.TypeError('The return value ($1) of the throw() on an iterator ($2) must be an object', innerResult, iterator);
+          }
+          // 5. Let done be ? IteratorComplete(innerResult).
+          const done = Q(yield* IteratorComplete(innerResult));
+          // 6. If done is true, then
+          if (done === Value.true) {
+            // a. Return ? IteratorValue(innerResult).
+            return Q(yield* IteratorValue(innerResult));
+          }
+          // 7. If generatorKind is async, then set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
+          if (generatorKind === 'async') {
+            received = EnsureCompletion(yield* AsyncGeneratorYield(Q(yield* IteratorValue(innerResult))));
+          } else { // 8. Else, set received to GeneratorYield(innerResult).
+            received = EnsureCompletion(yield* GeneratorYield(innerResult));
+          }
+        } else { // iii. Else,
+          // 1. NOTE: If iterator does not have a throw method, this throw is going to terminate the yield* loop. But first we need to give iterator a chance to clean up.
+          // 2. Let closeCompletion be NormalCompletion(empty).
+          const closeCompletion = NormalCompletion(undefined);
+          // 3. If generatorKind is async, perform ? AsyncIteratorClose(iteratorRecord, closeCompletion).
+          // 4. Else, perform ? IteratorClose(iteratorRecord, closeCompletion).
+          if (generatorKind === 'async') {
+            Q(yield* AsyncIteratorClose(iteratorRecord, closeCompletion));
+          } else {
+            Q(yield* IteratorClose(iteratorRecord, closeCompletion));
+          }
+          // 5. NOTE: The next step throws a TypeError to indicate that there was a yield* protocol violation: iterator does not have a throw method.
+          // 6. Throw a TypeError exception.
+          return Throw.TypeError('The iterator $1 does not provide a throw method', iterator);
+        }
+      } else { // c. Else,
+        // i. Assert: received is a return completion.
+        Assert(received instanceof ReturnCompletion);
+        // ii. Let return be ? GetMethod(iterator, "return").
+        const ret = Q(yield* GetMethod(iterator, Value('return')));
+        // iii. If return is undefined, then
+        if (ret === Value.undefined) {
+          let receivedValue = received.Value;
+          // 1. If generatorKind is async, then set receivedValue to ? Await(received.[[Value]]).
+          if (generatorKind === 'async') {
+            receivedValue = Q(yield* Await(receivedValue));
+          }
+          // 2. Return ReturnCompletion(receivedValue).
+          return ReturnCompletion(receivedValue);
+        }
+        // iv. Let innerReturnResult be ? Call(return, iterator, « received.[[Value]] »).
+        let innerReturnResult: Value = Q(yield* Call(ret, iterator, [received.Value]));
+        // v. If generatorKind is async, then set innerReturnResult to ? Await(innerReturnResult).
+        if (generatorKind === 'async') {
+          innerReturnResult = Q(yield* Await(innerReturnResult));
+        }
+        // vi. If Type(innerReturnResult) is not Object, throw a TypeError exception.
+        if (!(innerReturnResult instanceof ObjectValue)) {
+          return Throw.TypeError('The return value ($1) of the return() on an iterator ($2) must be an object', innerReturnResult, iterator);
+        }
+        // vii. Let done be ? IteratorComplete(innerReturnResult).
+        const done = Q(yield* IteratorComplete(innerReturnResult));
+        // viii. If done is true, then
+        if (done === Value.true) {
+          // 1. Set returnedValue to ? IteratorValue(innerReturnResult).
+          const returnedValue = Q(yield* IteratorValue(innerReturnResult));
+          // 2. Return ReturnCompletion(value).
+          return ReturnCompletion(returnedValue);
+        }
+        // ix. If generatorKind is async, then set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
+        if (generatorKind === 'async') {
+          received = EnsureCompletion(yield* AsyncGeneratorYield(Q(yield* IteratorValue(innerReturnResult))));
+        } else { // ixx. Else, set received to GeneratorYield(innerResult).
+          received = EnsureCompletion(yield* GeneratorYield(innerReturnResult));
+        }
+      }
+    }
+  }
+  if (AssignmentExpression) {
+    // 1. Let exprRef be the result of evaluating AssignmentExpression.
+    const exprRef = Q(yield* Evaluate(AssignmentExpression));
+    // 2. Let value be ? GetValue(exprRef).
+    const value = Q(yield* GetValue(exprRef));
+    // 3. Return ? Yield(value).
+    return Q(yield* Yield(value));
+  }
+  // 1. Return ? Yield(undefined).
+  return Q(yield* Yield(Value.undefined));
+}