@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/runtime-semantics/VariableStatement.mts

@@ -0,0 +1,72 @@
+import {
+  GetValue,
+  PutValue,
+  ResolveBinding,
+} from '../abstract-ops/all.mts';
+import {
+  NormalCompletion, Q, ReturnIfAbrupt, type PlainCompletion,
+} from '../completion.mts';
+import { Evaluate, type Evaluator } 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';
+
+/** https://tc39.es/ecma262/#sec-variable-statement-runtime-semantics-evaluation */
+//   VariableDeclaration :
+//     BindingIdentifier
+//     BindingIdentifier Initializer
+//     BindingPattern Initializer
+function* Evaluate_VariableDeclaration({ BindingIdentifier, Initializer, BindingPattern }: ParseNode.VariableDeclaration): Evaluator<PlainCompletion<void>> {
+  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(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 = yield* NamedEvaluation(Initializer as FunctionDeclaration, bindingId);
+    } else { // 4. Else,
+      // a. Let rhs be the result of evaluating Initializer.
+      const rhs = yield* Evaluate(Initializer);
+      // b. Let value be ? GetValue(rhs).
+      value = Q(GetValue(rhs));
+    }
+    // 5. Return ? PutValue(lhs, value).
+    return Q(PutValue(lhs, value));
+  }
+  // 1. Let rhs be the result of evaluating Initializer.
+  const rhs = yield* Evaluate(Initializer!);
+  // 2. Let rval be ? GetValue(rhs).
+  const rval = Q(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);
+    ReturnIfAbrupt(next);
+  }
+  return next;
+}
+
+/** https://tc39.es/ecma262/#sec-variable-statement-runtime-semantics-evaluation */
+//   VariableStatement : `var` VariableDeclarationList `;`
+export function* Evaluate_VariableStatement({ VariableDeclarationList }: ParseNode.VariableStatement): Evaluator<PlainCompletion<void>> {
+  const next = yield* Evaluate_VariableDeclarationList(VariableDeclarationList);
+  ReturnIfAbrupt(next);
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/WithStatement.mts

@@ -0,0 +1,33 @@
+import { surroundingAgent } from '../engine.mts';
+import { Value } from '../value.mts';
+import { ToObject, GetValue } from '../abstract-ops/all.mts';
+import { Evaluate } from '../evaluator.mts';
+import { ObjectEnvironmentRecord } from '../environment.mts';
+import {
+  UpdateEmpty,
+  Completion,
+  EnsureCompletion,
+  Q,
+} from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** 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 = yield* Evaluate(Expression);
+  // 2. Let obj be ? ToObject(? GetValue(val)).
+  const obj = Q(ToObject(Q(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 C = 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(C, Value.undefined));
+}

package/src/runtime-semantics/YieldExpression.mts

@@ -0,0 +1,175 @@
+import { surroundingAgent } from '../engine.mts';
+import { ObjectValue, Value } from '../value.mts';
+import {
+  Assert,
+  Call,
+  GeneratorYield,
+  GetGeneratorKind,
+  GetIterator,
+  GetMethod,
+  GetValue,
+  IteratorClose,
+  IteratorComplete,
+  IteratorValue,
+  AsyncGeneratorYield,
+  AsyncIteratorClose,
+  Yield,
+} from '../abstract-ops/all.mts';
+import {
+  Await,
+  NormalCompletion,
+  Q,
+  type ExpressionCompletion,
+  ReturnCompletion,
+  ThrowCompletion,
+} from '../completion.mts';
+import { Evaluate, type Evaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** 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): Evaluator<ExpressionCompletion | ReturnCompletion> {
+  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).
+    let value = Q(GetValue(exprRef));
+    // 4. Let iteratorRecord be ? GetIterator(value, generatorKind).
+    const iteratorRecord = Q(GetIterator(value, generatorKind));
+    // 5. Let iterator be iteratorRecord.[[Iterator]].
+    const iterator = iteratorRecord.Iterator;
+    // 6. Let received be NormalCompletion(undefined).
+    let received: ExpressionCompletion | 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(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 surroundingAgent.Throw('TypeError', 'NotAnObject', innerResult);
+        }
+        // iv. Let done be ? IteratorComplete(innerResult).
+        const done = Q(IteratorComplete(innerResult));
+        // v. If done is true, then
+        if (done === Value.true) {
+          // 1. Return ? IteratorValue(innerResult).
+          return Q(IteratorValue(innerResult));
+        }
+        // vi. If generatorKind is async, then set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
+        if (generatorKind === 'async') {
+          received = yield* AsyncGeneratorYield(Q(IteratorValue(innerResult)));
+        } else { // vii. Else, set received to GeneratorYield(innerResult).
+          received = 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(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(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 surroundingAgent.Throw('TypeError', 'NotAnObject', innerResult);
+          }
+          // 5. Let done be ? IteratorComplete(innerResult).
+          const done = Q(IteratorComplete(innerResult));
+          // 6. If done is true, then
+          if (done === Value.true) {
+            // a. Return ? IteratorValue(innerResult).
+            return Q(IteratorValue(innerResult));
+          }
+          // 7. If generatorKind is async, then set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
+          if (generatorKind === 'async') {
+            received = yield* AsyncGeneratorYield(Q(IteratorValue(innerResult)));
+          } else { // 8. Else, set received to GeneratorYield(innerResult).
+            received = 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(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 surroundingAgent.Throw('TypeError', 'IteratorThrowMissing');
+        }
+      } else { // c. Else,
+        // i. Assert: received is a return completion.
+        Assert(received instanceof ReturnCompletion);
+        // ii. Let return be ? GetMethod(iterator, "return").
+        const ret = Q(GetMethod(iterator, Value('return')));
+        // iii. If return is undefined, then
+        if (ret === Value.undefined) {
+          // Set value to received.[[Value]].
+          let value: Value = received.Value;
+          // 1. If generatorKind is async, then set received.[[Value]] to ? Await(received.[[Value]]).
+          if (generatorKind === 'async') {
+            value = Q(yield* Await(value));
+          }
+          // 2. Return ReturnCompletion(value).
+          return ReturnCompletion(value);
+        }
+        // iv. Let innerReturnResult be ? Call(return, iterator, « received.[[Value]] »).
+        let innerReturnResult: Value = Q(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 surroundingAgent.Throw('TypeError', 'NotAnObject', innerReturnResult);
+        }
+        // vii. Let done be ? IteratorComplete(innerReturnResult).
+        const done = Q(IteratorComplete(innerReturnResult));
+        // viii. If done is true, then
+        if (done === Value.true) {
+          // 1. Set value to ? IteratorValue(innerReturnResult).
+          value = Q(IteratorValue(innerReturnResult));
+          // 2. Return ReturnCompletion(value).
+          return ReturnCompletion(value);
+        }
+        // ix. If generatorKind is async, then set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
+        if (generatorKind === 'async') {
+          received = yield* AsyncGeneratorYield(Q(IteratorValue(innerReturnResult)));
+        } else { // ixx. Else, set received to GeneratorYield(innerResult).
+          received = yield* GeneratorYield(innerReturnResult);
+        }
+      }
+    }
+  }
+  if (AssignmentExpression) {
+    // 1. Let exprRef be the result of evaluating AssignmentExpression.
+    const exprRef = yield* Evaluate(AssignmentExpression);
+    // 2. Let value be ? GetValue(exprRef).
+    const value = Q(GetValue(exprRef));
+    // 3. Return ? Yield(value).
+    return Q(yield* Yield(value));
+  }
+  // 1. Return ? Yield(undefined).
+  return Q(yield* Yield(Value.undefined));
+}

package/src/runtime-semantics/all.mts

@@ -0,0 +1,108 @@
+export * from './IdentifierReference.mts';
+export * from './This.mts';
+export * from './Literal.mts';
+export * from './ClassExpression.mts';
+export * from './ClassDefinitionEvaluation.mts';
+export * from './DefineMethod.mts';
+export * from './PropertyName.mts';
+export * from './AdditiveExpression.mts';
+export * from './AssignmentExpression.mts';
+export * from './BitwiseOperators.mts';
+export * from './CoalesceExpression.mts';
+export * from './EmptyStatement.mts';
+export * from './ExponentiationExpression.mts';
+export * from './IfStatement.mts';
+export * from './ImportCall.mts';
+export * from './MultiplicativeExpression.mts';
+export * from './ThrowStatement.mts';
+export * from './UpdateExpression.mts';
+export * from './GlobalDeclarationInstantiation.mts';
+export * from './InstantiateFunctionObject.mts';
+export * from './Script.mts';
+export * from './ScriptBody.mts';
+export * from './StatementList.mts';
+export * from './ExpressionStatement.mts';
+export * from './VariableStatement.mts';
+export * from './FunctionDeclaration.mts';
+export * from './CallExpression.mts';
+export * from './EvaluateCall.mts';
+export * from './ArgumentListEvaluation.mts';
+export * from './EvaluateBody.mts';
+export * from './FunctionDeclarationInstantiation.mts';
+export * from './FunctionStatementList.mts';
+export * from './IteratorBindingInitialization.mts';
+export * from './ReturnStatement.mts';
+export * from './ParenthesizedExpression.mts';
+export * from './MemberExpression.mts';
+export * from './EvaluatePropertyAccess.mts';
+export * from './LexicalDeclaration.mts';
+export * from './ObjectLiteral.mts';
+export * from './PropertyDefinitionEvaluation.mts';
+export * from './FunctionExpression.mts';
+export * from './NamedEvaluation.mts';
+export * from './TryStatement.mts';
+export * from './Block.mts';
+export * from './ArrayLiteral.mts';
+export * from './UnaryExpression.mts';
+export * from './EqualityExpression.mts';
+export * from './LogicalANDExpression.mts';
+export * from './LogicalORExpression.mts';
+export * from './NewExpression.mts';
+export * from './ShiftExpression.mts';
+export * from './SuperCall.mts';
+export * from './SuperProperty.mts';
+export * from './BindingInitialization.mts';
+export * from './AsyncFunctionExpression.mts';
+export * from './RelationalExpression.mts';
+export * from './BreakableStatement.mts';
+export * from './LabelledEvaluation.mts';
+export * from './TemplateLiteral.mts';
+export * from './SwitchStatement.mts';
+export * from './CreateDynamicFunction.mts';
+export * from './GeneratorExpression.mts';
+export * from './ArrowFunction.mts';
+export * from './AsyncArrowFunction.mts';
+export * from './BreakStatement.mts';
+export * from './AsyncGeneratorExpression.mts';
+export * from './HoistableDeclaration.mts';
+export * from './CommaOperator.mts';
+export * from './YieldExpression.mts';
+export * from './StringIndexOf.mts';
+export * from './NumberToBigInt.mts';
+export * from './ConditionalExpression.mts';
+export * from './RegularExpressionLiteral.mts';
+export * from './RegExp.mts';
+export * from './StringPad.mts';
+export * from './TrimString.mts';
+export * from './NewTarget.mts';
+export * from './AwaitExpression.mts';
+export * from './ClassDeclaration.mts';
+export * from './WithStatement.mts';
+export * from './Module.mts';
+export * from './ModuleBody.mts';
+export * from './ImportDeclaration.mts';
+export * from './ExportDeclaration.mts';
+export * from './OptionalExpression.mts';
+export * from './TaggedTemplateExpression.mts';
+export * from './GetSubstitution.mts';
+export * from './ContinueStatement.mts';
+export * from './LabelledStatement.mts';
+export * from './MV.mts';
+export * from './ApplyStringOrNumericBinaryOperator.mts';
+export * from './EvaluateStringOrNumericBinaryExpression.mts';
+export * from './ImportMeta.mts';
+export * from './DebuggerStatement.mts';
+export * from './PropertyBindingInitialization.mts';
+export * from './KeyedBindingInitialization.mts';
+export * from './DestructuringAssignmentEvaluation.mts';
+export * from './RestBindingInitialization.mts';
+export * from './Unicode.mts';
+export * from './MethodDefinitionEvaluation.mts';
+export * from './ClassFieldDefinitionEvaluation.mts';
+export * from './InstantiateOrdinaryFunctionExpression.mts';
+export * from './InstantiateGeneratorFunctionExpression.mts';
+export * from './InstantiateArrowFunctionExpression.mts';
+export * from './InstantiateAsyncArrowFunctionExpression.mts';
+export * from './InstantiateAsyncFunctionExpression.mts';
+export * from './InstantiateAsyncGeneratorFunctionExpression.mts';
+export * from './ClassStaticBlockDefinitionEvaluation.mts';

package/src/static-semantics/BodyText.mts

@@ -0,0 +1,7 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-bodytext */
+//  RegularExpressionLiteral :: `/` RegularExpressionBody `/` RegularExpressionFlags
+export function BodyText(RegularExpressionLiteral: ParseNode.RegularExpressionLiteral) {
+  return RegularExpressionLiteral.RegularExpressionBody;
+}

package/src/static-semantics/BoundNames.mts

@@ -0,0 +1,101 @@
+import { OutOfRange, isArray } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { JSStringValue, Value } from '../value.mts';
+import { StringValue } from './all.mts';
+
+export function BoundNames(node: ParseNode | readonly ParseNode[]): JSStringValue[] {
+  if (isArray(node)) {
+    const names = [];
+    for (const item of node) {
+      names.push(...BoundNames(item));
+    }
+    return names;
+  }
+  switch (node.type) {
+    case 'BindingIdentifier':
+      return [StringValue(node)];
+    case 'LexicalDeclaration':
+      return BoundNames(node.BindingList);
+    case 'LexicalBinding':
+      if (node.BindingIdentifier) {
+        return BoundNames(node.BindingIdentifier);
+      }
+      return BoundNames(node.BindingPattern!);
+    case 'VariableStatement':
+      return BoundNames(node.VariableDeclarationList);
+    case 'VariableDeclaration':
+      if (node.BindingIdentifier) {
+        return BoundNames(node.BindingIdentifier);
+      }
+      return BoundNames(node.BindingPattern!);
+    case 'ForDeclaration':
+      return BoundNames(node.ForBinding);
+    case 'ForBinding':
+      if (node.BindingIdentifier) {
+        return BoundNames(node.BindingIdentifier);
+      }
+      return BoundNames(node.BindingPattern!);
+    case 'FunctionDeclaration':
+    case 'GeneratorDeclaration':
+    case 'AsyncFunctionDeclaration':
+    case 'AsyncGeneratorDeclaration':
+    case 'ClassDeclaration':
+      if (node.BindingIdentifier) {
+        return BoundNames(node.BindingIdentifier);
+      }
+      return [Value('*default*')];
+    case 'ImportSpecifier':
+      return BoundNames(node.ImportedBinding);
+    case 'ExportDeclaration':
+      if (node.FromClause || node.NamedExports) {
+        return [];
+      }
+      if (node.VariableStatement) {
+        return BoundNames(node.VariableStatement);
+      }
+      if (node.Declaration) {
+        return BoundNames(node.Declaration);
+      }
+      if (node.HoistableDeclaration) {
+        const declarationNames = BoundNames(node.HoistableDeclaration);
+        return declarationNames;
+      }
+      if (node.ClassDeclaration) {
+        const declarationNames = BoundNames(node.ClassDeclaration);
+        return declarationNames;
+      }
+      if (node.AssignmentExpression) {
+        return [Value('*default*')];
+      }
+      throw new OutOfRange('BoundNames', node);
+    case 'SingleNameBinding':
+      return BoundNames(node.BindingIdentifier);
+    case 'BindingRestElement':
+      if (node.BindingIdentifier) {
+        return BoundNames(node.BindingIdentifier);
+      }
+      return BoundNames(node.BindingPattern!);
+    case 'BindingRestProperty':
+      return BoundNames(node.BindingIdentifier);
+    case 'BindingElement':
+      return BoundNames(node.BindingPattern);
+    case 'BindingProperty':
+      return BoundNames(node.BindingElement);
+    case 'ObjectBindingPattern': {
+      const names = BoundNames(node.BindingPropertyList);
+      if (node.BindingRestProperty) {
+        names.push(...BoundNames(node.BindingRestProperty));
+      }
+      return names;
+    }
+    case 'ArrayBindingPattern': {
+      const names = BoundNames(node.BindingElementList);
+      if (node.BindingRestElement) {
+        names.push(...BoundNames(node.BindingRestElement));
+      }
+      return names;
+    }
+    default:
+      return [];
+  }
+}

package/src/static-semantics/CharacterValue.mts

@@ -0,0 +1,92 @@
+import { OutOfRange } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { UTF16SurrogatePairToCodePoint } from './all.mts';
+
+export function CharacterValue(node: ParseNode.RegExp.CharacterEscape | ParseNode.RegExp.RegExpUnicodeEscapeSequence | ParseNode.RegExp.ClassAtom | ParseNode.RegExp.ClassEscape): number {
+  switch (node.type) {
+    case 'CharacterEscape':
+      switch (true) {
+        case !!node.ControlEscape:
+          switch (node.ControlEscape) {
+            case 't':
+              return 0x0009;
+            case 'n':
+              return 0x000A;
+            case 'v':
+              return 0x000B;
+            case 'f':
+              return 0x000C;
+            case 'r':
+              return 0x000D;
+            default:
+              throw new OutOfRange('Evaluate_CharacterEscape', node);
+          }
+        case !!node.ControlLetter: {
+          // 1. Let ch be the code point matched by ControlLetter.
+          const ch = node.ControlLetter!;
+          // 2. Let i be ch's code point value.
+          const i = ch.codePointAt(0)!;
+          // 3. Return the remainder of dividing i by 32.
+          return i % 32;
+        }
+        case !!node.HexEscapeSequence:
+          // 1. Return the numeric value of the code unit that is the SV of HexEscapeSequence.
+          return Number.parseInt(`${node.HexEscapeSequence!.HexDigit_a}${node.HexEscapeSequence!.HexDigit_b}`, 16);
+        case !!node.RegExpUnicodeEscapeSequence:
+          return CharacterValue(node.RegExpUnicodeEscapeSequence!);
+        case node.subtype === '0':
+          // 1. Return the code point value of U+0000 (NULL).
+          return 0x0000;
+        case !!node.IdentityEscape: {
+          // 1. Let ch be the code point matched by IdentityEscape.
+          const ch = node.IdentityEscape!.codePointAt(0)!;
+          // 2. Return the code point value of ch.
+          return ch;
+        }
+        default:
+          throw new OutOfRange('Evaluate_CharacterEscape', node);
+      }
+    case 'RegExpUnicodeEscapeSequence':
+      switch (true) {
+        case 'Hex4Digits' in node:
+          return node.Hex4Digits!;
+        case 'CodePoint' in node:
+          return node.CodePoint!;
+        case 'HexTrailSurrogate' in node:
+          return UTF16SurrogatePairToCodePoint(node.HexLeadSurrogate!, node.HexTrailSurrogate!);
+        case 'HexLeadSurrogate' in node:
+          return node.HexLeadSurrogate!;
+        default:
+          throw new OutOfRange('Evaluate_CharacterEscape', node);
+      }
+    case 'ClassAtom':
+      switch (true) {
+        case node.value === '-':
+          // 1. Return the code point value of U+002D (HYPHEN-MINUS).
+          return 0x002D;
+        case !!node.SourceCharacter: {
+          // 1. Let ch be the code point matched by SourceCharacter.
+          const ch = node.SourceCharacter!.codePointAt(0)!;
+          // 2. Return ch.
+          return ch;
+        }
+        default:
+          throw new OutOfRange('CharacterValue', node);
+      }
+    case 'ClassEscape':
+      switch (true) {
+        case node.value === 'b':
+          // 1. Return the code point value of U+0008 (BACKSPACE).
+          return 0x0008;
+        case node.value === '-':
+          // 1. Return the code point value of U+002D (HYPHEN-MINUS).
+          return 0x002D;
+        case !!node.CharacterEscape:
+          return CharacterValue(node.CharacterEscape!);
+        default:
+          throw new OutOfRange('CharacterValue', node);
+      }
+    default:
+      throw new OutOfRange('CharacterValue', node);
+  }
+}

package/src/static-semantics/CodePointAt.mts

@@ -0,0 +1,53 @@
+import { Assert } from '../abstract-ops/all.mts';
+import { X } from '../completion.mts';
+import { isLeadingSurrogate, isTrailingSurrogate } from '../parser/Lexer.mts';
+import { UTF16SurrogatePairToCodePoint } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-codepointat */
+export function CodePointAt(string: string, position: number) {
+  // 1 .Let size be the length of string.
+  const size = string.length;
+  // 2. Assert: position ≥ 0 and position < size.
+  Assert(position >= 0 && position < size);
+  // 3. Let first be the code unit at index position within string.
+  const first = string.charCodeAt(position);
+  // 4. Let cp be the code point whose numeric value is that of first.
+  let cp = first;
+  // 5. If first is not a leading surrogate or trailing surrogate, then
+  if (!isLeadingSurrogate(first) && !isTrailingSurrogate(first)) {
+    // a. Return the Record { [[CodePoint]]: cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]: false }.
+    return {
+      CodePoint: cp,
+      CodeUnitCount: 1,
+      IsUnpairedSurrogate: false,
+    };
+  }
+  // 6. If first is a trailing surrogate or position + 1 = size, then
+  if (isTrailingSurrogate(first) || position + 1 === size) {
+    // a. Return the Record { [[CodePoint]]: cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]: true }.
+    return {
+      CodePoint: cp,
+      CodeUnitCount: 1,
+      IsUnpairedSurrogate: true,
+    };
+  }
+  // 7. Let second be the code unit at index position + 1 within string.
+  const second = string.charCodeAt(position + 1);
+  // 8. If seconds is not a trailing surrogate, then
+  if (!isTrailingSurrogate(second)) {
+    // a. Return the Record { [[CodePoint]]: cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]: true }.
+    return {
+      CodePoint: cp,
+      CodeUnitCount: 1,
+      IsUnpairedSurrogate: true,
+    };
+  }
+  // 9. Set cp to ! UTF16SurrogatePairToCodePoint(first, second).
+  cp = X(UTF16SurrogatePairToCodePoint(first, second));
+  // 10. Return the Record { [[CodePoint]]: cp, [[CodeUnitCount]]: 2, [[IsUnpairedSurrogate]]: false }.
+  return {
+    CodePoint: cp,
+    CodeUnitCount: 2,
+    IsUnpairedSurrogate: false,
+  };
+}

package/src/static-semantics/CodePointsToString.mts

@@ -0,0 +1,16 @@
+import { UTF16EncodeCodePoint } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-codepointstostring */
+export function CodePointsToString(text: string) {
+  // 1. Let result be the empty String.
+  let result = '';
+  // 2. For each code point cp in text, do
+  for (const cp of text) {
+    // a. Set result to the string-concatenation of result and UTF16EncodeCodePoint(cp).
+    // TODO(ts): Argument of type 'string' is not assignable to parameter of type 'number'. Is this a mistake?
+    // @ts-expect-error
+    result += UTF16EncodeCodePoint(cp);
+  }
+  // 3. Return result.
+  return result;
+}