@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/abstract-ops/generator-operations.mts

@@ -0,0 +1,291 @@
+import {
+  Await,
+  Completion,
+  NormalCompletion,
+  Q, X,
+  EnsureCompletion,
+  AbruptCompletion,
+  type ExpressionCompletion,
+} from '../completion.mts';
+import { ExecutionContext, surroundingAgent } from '../engine.mts';
+import {
+  JSStringValue, ObjectValue, UndefinedValue, Value,
+} from '../value.mts';
+import {
+  Evaluate, type YieldEvaluator,
+} from '../evaluator.mts';
+import { __ts_cast__, resume, type Mutable } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Assert,
+  AsyncGeneratorYield,
+  CreateIteratorResultObject,
+  OrdinaryObjectCreate,
+  RequireInternalSlot,
+  SameValue,
+  type OrdinaryObject,
+} from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-generator-objects */
+export interface GeneratorObject extends OrdinaryObject {
+  GeneratorState: 'suspendedStart' | 'suspendedYield' | 'executing' | 'completed' | UndefinedValue;
+  GeneratorContext: ExecutionContext | null;
+  readonly GeneratorBrand: JSStringValue | undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-generatorstart */
+export function GeneratorStart(generator: GeneratorObject, generatorBody: ParseNode.GeneratorBody | (() => YieldEvaluator)): ExpressionCompletion {
+  // 1. Assert: The value of generator.[[GeneratorState]] is undefined.
+  Assert(generator.GeneratorState === Value.undefined);
+  // 2. Let genContext be the running execution context.
+  const genContext = surroundingAgent.runningExecutionContext;
+  // 3. Set the Generator component of genContext to generator.
+  genContext.Generator = generator;
+  // 4. Set the code evaluation state of genContext such that when evaluation is resumed
+  //    for that execution context the following steps will be performed:
+  genContext.codeEvaluationState = (function* resumer(): YieldEvaluator {
+    // a. If generatorBody is a Parse Node, then
+    //    i. Let result be the result of evaluating generatorBody.
+    // b. Else,
+    //    i. Assert: generatorBody is an Abstract Closure.
+    //    ii. Let result be generatorBody().
+    const result = EnsureCompletion(
+      // Note: Engine262 can only perform the "If generatorBody is an Abstract Closure" check:
+      yield* typeof generatorBody === 'function'
+        ? generatorBody()
+        : Evaluate(generatorBody),
+    );
+    // c. Assert: If we return here, the generator either threw an exception or
+    //    performed either an implicit or explicit return.
+    // d. Remove genContext from the execution context stack and restore the execution context
+    //    that is at the top of the execution context stack as the running execution context.
+    surroundingAgent.executionContextStack.pop(genContext);
+    // e. Set generator.[[GeneratorState]] to completed.
+    generator.GeneratorState = 'completed';
+    // f. Once a generator enters the completed state it never leaves it and its
+    //    associated execution context is never resumed. Any execution state associated
+    //    with generator can be discarded at this point.
+    genContext.codeEvaluationState = undefined;
+    // g. If result.[[Type]] is normal, let resultValue be undefined.
+    let resultValue;
+    if (result.Type === 'normal') {
+      resultValue = Value.undefined;
+    } else if (result.Type === 'return') {
+      // h. Else if result.[[Type]] is return, let resultValue be result.[[Value]].
+      resultValue = result.Value;
+    } else { // i. Else,
+      // i. Assert: result.[[Type]] is throw.
+      Assert(result.Type === 'throw');
+      // ii. Return Completion(result).
+      return Q(result);
+    }
+    // j. Return CreateIteratorResultObject(resultValue, true).
+    return X(CreateIteratorResultObject(resultValue, Value.true));
+  }());
+  // 5. Set generator.[[GeneratorContext]] to genContext.
+  generator.GeneratorContext = genContext;
+  // 6. Set generator.[[GeneratorState]] to suspendedStart.
+  generator.GeneratorState = 'suspendedStart';
+  // 7. Return NormalCompletion(undefined).
+  return NormalCompletion(Value.undefined);
+}
+
+export function generatorBrandToErrorMessageType(generatorBrand: JSStringValue | undefined) {
+  let expectedType;
+  if (generatorBrand !== undefined) {
+    expectedType = generatorBrand.stringValue();
+    if (expectedType.startsWith('%') && expectedType.endsWith('Prototype%')) {
+      expectedType = expectedType.slice(1, -10).trim();
+      if (expectedType.endsWith('Iterator')) {
+        expectedType = `${expectedType.slice(0, -8).trim()} Iterator`;
+      }
+    }
+  }
+  return expectedType;
+}
+
+/** https://tc39.es/ecma262/#sec-generatorvalidate */
+export function GeneratorValidate(generator: Value, generatorBrand: JSStringValue | undefined) {
+  // 1. Perform ? RequireInternalSlot(generator, [[GeneratorState]]).
+  Q(RequireInternalSlot(generator, 'GeneratorState'));
+  // 2. Perform ? RequireInternalSlot(generator, [[GeneratorBrand]]).
+  Q(RequireInternalSlot(generator, 'GeneratorBrand'));
+  __ts_cast__<GeneratorObject>(generator);
+  // 3. If generator.[[GeneratorBrand]] is not the same value as generatorBrand, throw a TypeError exception.
+  const brand = generator.GeneratorBrand;
+  if (
+    brand === undefined || generatorBrand === undefined
+      ? brand !== generatorBrand
+      : SameValue(brand, generatorBrand) === Value.false
+  ) {
+    return surroundingAgent.Throw(
+      'TypeError',
+      'NotATypeObject',
+      generatorBrandToErrorMessageType(generatorBrand) || 'Generator',
+      generator,
+    );
+  }
+  // 4. Assert: generator also has a [[GeneratorContext]] internal slot.
+  Assert('GeneratorContext' in generator);
+  // 5. Let state be generator.[[GeneratorState]].
+  const state = generator.GeneratorState;
+  // 6. If state is executing, throw a TypeError exception.
+  if (state === 'executing') {
+    return surroundingAgent.Throw('TypeError', 'GeneratorRunning');
+  }
+  // 7. Return state.
+  return state;
+}
+
+/** https://tc39.es/ecma262/#sec-generatorresume */
+export function GeneratorResume(generator: Value, value: Value | void, generatorBrand: JSStringValue | undefined) {
+  // 1. Let state be ? GeneratorValidate(generator, generatorBrand).
+  const state = Q(GeneratorValidate(generator, generatorBrand));
+  __ts_cast__<GeneratorObject>(generator);
+  // 2. If state is completed, return CreateIteratorResultObject(undefined, true).
+  if (state === 'completed') {
+    return X(CreateIteratorResultObject(Value.undefined, Value.true));
+  }
+  // 3. Assert: state is either suspendedStart or suspendedYield.
+  Assert(state === 'suspendedStart' || state === 'suspendedYield');
+  // 4. Let genContext be generator.[[GeneratorContext]].
+  const genContext = generator.GeneratorContext!;
+  // 5. Let methodContext be the running execution context.
+  // 6. Suspend methodContext.
+  const methodContext = surroundingAgent.runningExecutionContext;
+  // 7. Set generator.[[GeneratorState]] to executing.
+  generator.GeneratorState = 'executing';
+  // 8. Push genContext onto the execution context stack.
+  surroundingAgent.executionContextStack.push(genContext);
+  // 9. Resume the suspended evaluation of genContext using NormalCompletion(value) as
+  //    the result of the operation that suspended it. Let result be the value returned by
+  //    the resumed computation.
+  const result = EnsureCompletion(resume(genContext, NormalCompletion(value)));
+  // 10. Assert: When we return here, genContext has already been removed from the execution
+  //     context stack and methodContext is the currently running execution context.
+  Assert(surroundingAgent.runningExecutionContext === methodContext);
+  // 11. Return Completion(result).
+  return Completion(result);
+}
+
+/** https://tc39.es/ecma262/#sec-generatorresumeabrupt */
+export function GeneratorResumeAbrupt(generator: Value, abruptCompletion: AbruptCompletion, generatorBrand: JSStringValue | undefined) {
+  // 1. Let state be ? GeneratorValidate(generator, generatorBrand).
+  let state = Q(GeneratorValidate(generator, generatorBrand));
+  __ts_cast__<GeneratorObject>(generator);
+  // 2. If state is suspendedStart, then
+  if (state === 'suspendedStart') {
+    // a. Set generator.[[GeneratorState]] to completed.
+    generator.GeneratorState = 'completed';
+    // b. Once a generator enters the completed state it never leaves it and its
+    //    associated execution context is never resumed. Any execution state associate
+    //    with generator can be discarded at this point.
+    generator.GeneratorContext = null;
+    // c. Set state to completed.
+    state = 'completed';
+  }
+  // 3. If state is completed, then
+  if (state === 'completed') {
+    // a. If abruptCompletion.[[Type]] is return, then
+    if (abruptCompletion.Type === 'return') {
+      // i. Return CreateIteratorResultObject(abruptCompletion.[[Value]], true).
+      return X(CreateIteratorResultObject(abruptCompletion.Value, Value.true));
+    }
+    // b. Return Completion(abruptCompletion).
+    return Completion(abruptCompletion);
+  }
+  // 4. Assert: state is suspendedYield.
+  Assert(state === 'suspendedYield');
+  // 5. Let genContext be generator.[[GeneratorContext]].
+  const genContext = generator.GeneratorContext!;
+  // 6. Let methodContext be the running execution context.
+  // 7. Suspend methodContext.
+  const methodContext = surroundingAgent.runningExecutionContext;
+  // 8. Set generator.[[GeneratorState]] to executing.
+  generator.GeneratorState = 'executing';
+  // 9. Push genContext onto the execution context stack.
+  surroundingAgent.executionContextStack.push(genContext);
+  // 10. Resume the suspended evaluation of genContext using abruptCompletion as the
+  //     result of the operation that suspended it. Let result be the completion record
+  //     returned by the resumed computation.
+  const result = EnsureCompletion(resume(genContext, abruptCompletion));
+  // 11. Assert: When we return here, genContext has already been removed from the
+  //     execution context stack and methodContext is the currently running execution context.
+  Assert(surroundingAgent.runningExecutionContext === methodContext);
+  // 12. Return Completion(result).
+  return Completion(result);
+}
+
+/** https://tc39.es/ecma262/#sec-getgeneratorkind */
+export function GetGeneratorKind(): 'async' | 'sync' | 'non-generator' {
+  // 1. Let genContext be the running execution context.
+  const genContext = surroundingAgent.runningExecutionContext;
+  // 2. If genContext does not have a Generator component, return non-generator.
+  if (!genContext.Generator) {
+    return 'non-generator';
+  }
+  // 3. Let generator be the Generator component of genContext.
+  const generator = genContext.Generator;
+  // 4. If generator has an [[AsyncGeneratorState]] internal slot, return async.
+  if ('AsyncGeneratorState' in generator) {
+    return 'async';
+  }
+  // 5. Else, return sync.
+  return 'sync';
+}
+
+/** https://tc39.es/ecma262/#sec-generatoryield */
+export function* GeneratorYield(iterNextObj: ObjectValue): YieldEvaluator {
+  // 1. Assert: iterNextObj is an Object that implements the IteratorResult interface.
+  // 2. Let genContext be the running execution context.
+  const genContext = surroundingAgent.runningExecutionContext;
+  // 3. Assert: genContext is the execution context of a generator.
+  Assert(genContext.Generator !== undefined);
+  // 4. Let generator be the value of the Generator component of genContext.
+  const generator = genContext.Generator as GeneratorObject;
+  // 5. Assert: GetGeneratorKind is sync.
+  Assert(GetGeneratorKind() === 'sync');
+  // 6. Set generator.GeneratorState to suspendedYield.
+  generator.GeneratorState = 'suspendedYield';
+  // 7. Remove genContext from the execution context stack.
+  surroundingAgent.executionContextStack.pop(genContext);
+  // 8. Set the code evaluation state of genContext such that when evaluation is resumed with
+  //    a Completion resumptionValue the following steps will be performed:
+  //      a. Return resumptionValue
+  const resumptionValue = yield iterNextObj;
+  // 9. Return NormalCompletion(iterNextObj).
+  // TODO
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return resumptionValue as any;
+  // 10. NOTE: this returns to the evaluation of the operation that had most previously resumed evaluation of genContext.
+}
+
+/** https://tc39.es/ecma262/#sec-yield */
+export function* Yield(value: Value): YieldEvaluator {
+  // 1. Let generatorKind be GetGeneratorKind().
+  const generatorKind = GetGeneratorKind();
+  // 2. If generatorKind is async, return ? AsyncGeneratorYield(? Await(value)).
+  if (generatorKind === 'async') {
+    return Q(yield* AsyncGeneratorYield(Q(yield* Await(value))));
+  }
+  // 3. Otherwise, return ? GeneratorYield(CreateIteratorResultObject(value, false)).
+  return Q(yield* GeneratorYield(CreateIteratorResultObject(value, Value.false)));
+}
+
+/** https://tc39.es/ecma262/#sec-createiteratorfromclosure */
+export function CreateIteratorFromClosure(closure: () => YieldEvaluator, generatorBrand: JSStringValue | undefined, generatorPrototype: ObjectValue) {
+  Assert(typeof closure === 'function');
+  // 1. NOTE: closure can contain uses of the Yield shorthand to yield an IteratorResult object.
+  // 2. Let internalSlotsList be « [[GeneratorState]], [[GeneratorContext]], [[GeneratorBrand]] ».
+  const internalSlotsList = ['GeneratorState', 'GeneratorContext', 'GeneratorBrand'];
+  // 3. Let generator be ! OrdinaryObjectCreate(generatorPrototype, internalSlotsList).
+  const generator = X(OrdinaryObjectCreate(generatorPrototype, internalSlotsList)) as Mutable<GeneratorObject>;
+  // 4. Set generator.[[GeneratorBrand]] to generatorBrand.
+  generator.GeneratorBrand = generatorBrand;
+  // 5. Set generator.[[GeneratorState]] to undefined.
+  generator.GeneratorState = Value.undefined;
+  // 6. Perform ! GeneratorStart(generator, closure).
+  X(GeneratorStart(generator, closure));
+  // 7. Return generator.
+  return generator;
+}

package/src/abstract-ops/global-object.mts

@@ -0,0 +1,386 @@
+import { ExecutionContext, HostEnsureCanCompileStrings, surroundingAgent } from '../engine.mts';
+import { JSStringValue, NullValue, Value } from '../value.mts';
+import { InstantiateFunctionObject } from '../runtime-semantics/all.mts';
+import {
+  IsStrict,
+  VarDeclaredNames,
+  VarScopedDeclarations,
+  LexicallyScopedDeclarations,
+  BoundNames,
+  IsConstantDeclaration,
+  ContainsArguments,
+} from '../static-semantics/all.mts';
+import {
+  NormalCompletion,
+  EnsureCompletion,
+  Q, X,
+  type ExpressionCompletion,
+  ThrowCompletion,
+  type PlainCompletion,
+} from '../completion.mts';
+import { wrappedParse } from '../parse.mts';
+import {
+  DeclarativeEnvironmentRecord,
+  EnvironmentRecord,
+  FunctionEnvironmentRecord,
+  GlobalEnvironmentRecord,
+  ObjectEnvironmentRecord,
+  PrivateEnvironmentRecord,
+} from '../environment.mts';
+import { Evaluate } from '../evaluator.mts';
+import { __ts_cast__, JSStringSet, unwind } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { Assert, GetThisEnvironment, Realm } from './all.mts';
+
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-global-object */
+
+/** https://tc39.es/ecma262/#sec-performeval */
+export function PerformEval(x: Value, callerRealm: Realm, strictCaller: boolean, direct: boolean): ExpressionCompletion {
+  // 1. Assert: If direct is false, then strictCaller is also false.
+  if (direct === false) {
+    Assert(strictCaller === false);
+  }
+  // 2. If Type(x) is not String, return x.
+  if (!(x instanceof JSStringValue)) {
+    return x;
+  }
+  // 3. Let evalRealm be the current Realm Record.
+  const evalRealm = surroundingAgent.currentRealmRecord;
+  // 4. Perform ? HostEnsureCanCompileStrings(callerRealm, evalRealm).
+  Q(HostEnsureCanCompileStrings(callerRealm, evalRealm));
+  // 5. Let inFunction be false.
+  let inFunction = false;
+  // 6. Let inMethod be false.
+  let inMethod = false;
+  // 7. Let inDerivedConstructor be false.
+  let inDerivedConstructor = false;
+  // 8. Let inClassFieldInitializer be false.
+  let inClassFieldInitializer = false;
+  // 9. If direct is true, then
+  if (direct === true) {
+    // a. Let thisEnv be ! GetThisEnvironment().
+    const thisEnv = X(GetThisEnvironment());
+    // b. If thisEnv is a function Environment Record, then
+    if (thisEnv instanceof FunctionEnvironmentRecord) {
+      // i. Let F be thisEnv.[[FunctionObject]].
+      const F = thisEnv.FunctionObject;
+      // ii. Let inFunction be true.
+      inFunction = true;
+      // iii. Let inMethod be thisEnv.HasSuperBinding().
+      inMethod = thisEnv.HasSuperBinding() === Value.true;
+      // iv. If F.[[ConstructorKind]] is derived, set inDerivedConstructor to true.
+      if (F.ConstructorKind === 'derived') {
+        inDerivedConstructor = true;
+      }
+      // v. Let classFieldIntializerName be F.[[ClassFieldInitializerName]].
+      const classFieldIntializerName = F.ClassFieldInitializerName;
+      // vi. If classFieldIntializerName is not empty, set inClassFieldInitializer to true.
+      if (classFieldIntializerName !== undefined) {
+        inClassFieldInitializer = true;
+      }
+    }
+  }
+  // 10. Perform the following substeps in an implementation-dependent order, possibly interleaving parsing and error detection:
+  //   a. Let script be ParseText(! StringToCodePoints(x), Script).
+  //   b. If script is a List of errors, throw a SyntaxError exception.
+  //   c. If script Contains ScriptBody is false, return undefined.
+  //   d. Let body be the ScriptBody of script.
+  //   e. If inFunction is false, and body Contains NewTarget, throw a SyntaxError exception.
+  //   f. If inMethod is false, and body Contains SuperProperty, throw a SyntaxError exception.
+  //   g. If inDerivedConstructor is false, and body Contains SuperCall, throw a SyntaxError exception.
+  //   h. If inClassFieldInitializer is true, and ContainsArguments of body is true, throw a SyntaxError exception.
+  const privateIdentifiers: string[] = [];
+  let pointer = direct ? surroundingAgent.runningExecutionContext.PrivateEnvironment : Value.null;
+  while (!(pointer instanceof NullValue)) {
+    for (const binding of pointer.Names) {
+      privateIdentifiers.push(binding.Description.stringValue());
+    }
+    pointer = pointer.OuterPrivateEnvironment;
+  }
+  const script = wrappedParse({ source: x.stringValue() }, (parser) => parser.scope.with({
+    strict: strictCaller,
+    newTarget: inFunction,
+    superProperty: inMethod,
+    superCall: inDerivedConstructor,
+    private: privateIdentifiers.length > 0,
+  }, () => {
+    privateIdentifiers.forEach((name) => {
+      parser.scope.privateScope!.names.set(name, new Set(['field']));
+    });
+    return parser.parseScript();
+  }));
+  if (Array.isArray(script)) {
+    return ThrowCompletion(script[0]);
+  }
+  if (!script.ScriptBody) {
+    return Value.undefined;
+  }
+  const body = script.ScriptBody;
+  if (inClassFieldInitializer && ContainsArguments(body)) {
+    return surroundingAgent.Throw('SyntaxError', 'UnexpectedToken');
+  }
+  // 11. If strictCaller is true, let strictEval be true.
+  // 12. Else, let strictEval be IsStrict of script.
+  let strictEval;
+  if (strictCaller === true) {
+    strictEval = true;
+  } else {
+    strictEval = IsStrict(script);
+  }
+  // 13. Let runningContext be the running execution context.
+  const runningContext = surroundingAgent.runningExecutionContext;
+  let lexEnv;
+  let varEnv;
+  let privateEnv;
+  // 14. NOTE: If direct is true, runningContext will be the execution context that performed the direct eval.
+  //     If direct is false, runningContext will be the execution context for the invocation of the eval function.
+  // 15. If direct is true, then
+  if (direct === true) {
+    // a. Let lexEnv be NewDeclarativeEnvironment(runningContext's LexicalEnvironment).
+    lexEnv = new DeclarativeEnvironmentRecord(runningContext.LexicalEnvironment);
+    // b. Let varEnv be runningContext's VariableEnvironment.
+    varEnv = runningContext.VariableEnvironment;
+    // c. Let privateEnv be runningContext's PrivateEnvironment.
+    privateEnv = runningContext.PrivateEnvironment;
+  } else { // 16. Else,
+    // a. Let lexEnv be NewDeclarativeEnvironment(evalRealm.[[GlobalEnv]]).
+    lexEnv = new DeclarativeEnvironmentRecord(evalRealm.GlobalEnv);
+    // b. Let varEnv be evalRealm.[[GlobalEnv]].
+    varEnv = evalRealm.GlobalEnv;
+    // c. Let privateEnv be null.
+    privateEnv = Value.null;
+  }
+  // 17. If strictEval is true, set varEnv to lexEnv.
+  if (strictEval === true) {
+    varEnv = lexEnv;
+  }
+  // 18. If runningContext is not already suspended, suspend runningContext.
+  // 19. Let evalContext be a new ECMAScript code execution context.
+  const evalContext = new ExecutionContext();
+  // 20. Set evalContext's Function to null.
+  evalContext.Function = Value.null;
+  // 21. Set evalContext's Realm to evalRealm.
+  evalContext.Realm = evalRealm;
+  // 22. Set evalContext's ScriptOrModule to runningContext's ScriptOrModule.
+  evalContext.ScriptOrModule = runningContext.ScriptOrModule;
+  // 23. Set evalContext's VariableEnvironment to varEnv.
+  evalContext.VariableEnvironment = varEnv;
+  // 24. Set evalContext's LexicalEnvironment to lexEnv.
+  evalContext.LexicalEnvironment = lexEnv;
+  // 25. Set evalContext's PrivateEnvironment to privateEnv.
+  evalContext.PrivateEnvironment = privateEnv;
+  // 26. Push evalContext onto the execution context stack.
+  surroundingAgent.executionContextStack.push(evalContext);
+  // 27. Let result be EvalDeclarationInstantiation(body, varEnv, lexEnv, privateEnv, strictEval).
+  let result: PlainCompletion<void | Value> = EnsureCompletion(EvalDeclarationInstantiation(body, varEnv, lexEnv, privateEnv, strictEval));
+  // 28. If result.[[Type]] is normal, then
+  if (result.Type === 'normal') {
+    // a. Set result to the result of evaluating body.
+    result = EnsureCompletion(unwind(Evaluate(body)) as PlainCompletion<void | Value>);
+  }
+  // 29. If result.[[Type]] is normal and result.[[Value]] is empty, then
+  if (result.Type === 'normal' && result.Value === undefined) {
+    // a. Set result to NormalCompletion(undefined).
+    result = NormalCompletion(Value.undefined);
+  }
+  // 30. Suspend evalContext and remove it from the execution context stack.
+  // 31. Resume the context that is now on the top of the execution context stack as the running execution context.
+  surroundingAgent.executionContextStack.pop(evalContext);
+  // 32. Return Completion(result).
+  return Q(result)!;
+}
+
+/** https://tc39.es/ecma262/#sec-evaldeclarationinstantiation */
+function EvalDeclarationInstantiation(body: ParseNode.ScriptBody, varEnv: EnvironmentRecord, lexEnv: DeclarativeEnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue, strict: boolean): PlainCompletion<void> {
+  // 1. Let varNames be the VarDeclaredNames of body.
+  const varNames = VarDeclaredNames(body);
+  // 2. Let varDeclarations be the VarScopedDeclarations of body.
+  const varDeclarations = VarScopedDeclarations(body);
+  // 3. If strict is false, then
+  if (strict === false) {
+    // a. If varEnv is a global Environment Record, then
+    if (varEnv instanceof GlobalEnvironmentRecord) {
+      // i. For each name in varNames, do
+      for (const name of varNames) {
+        // 1. If varEnv.HasLexicalDeclaration(name) is true, throw a SyntaxError exception.
+        if (varEnv.HasLexicalDeclaration(name) === Value.true) {
+          return surroundingAgent.Throw('SyntaxError', 'AlreadyDeclared', name);
+        }
+        // 2. NOTE: eval will not create a global var declaration that would be shadowed by a global lexical declaration.
+      }
+    }
+    // b. Let thisLex be lexEnv.
+    let thisEnv: EnvironmentRecord = lexEnv;
+    // c. Assert: The following loop will terminate.
+    // d. Repeat, while thisEnv is not the same as varEnv,
+    while (thisEnv !== varEnv) {
+      __ts_cast__<EnvironmentRecord>(thisEnv);
+      // i. If thisEnv is not an object Environment Record, then
+      if (!(thisEnv instanceof ObjectEnvironmentRecord)) {
+        // 1. NOTE: The environment of with statements cannot contain any lexical declaration so it doesn't need to be checked for var/let hoisting conflicts.
+        // 2. For each name in varNames, do
+        for (const name of varNames) {
+          // a. If thisEnv.HasBinding(name) is true, then
+          if (thisEnv.HasBinding(name) === Value.true) {
+            // i. Throw a SyntaxError exception.
+            return surroundingAgent.Throw('SyntaxError', 'AlreadyDeclared', name);
+            // ii. NOTE: Annex B.3.5 defines alternate semantics for the above step.
+          }
+          // b. NOTE: A direct eval will not hoist var declaration over a like-named lexical declaration
+        }
+      }
+      // ii. Set thisEnv to thisEnv.[[OuterEnv]].
+      thisEnv = thisEnv.OuterEnv as EnvironmentRecord;
+    }
+  }
+  // 4. Let privateIdentifiers be a new empty List.
+  const privateIdentifiers = [];
+  // 5. Let pointer be privateEnv.
+  let pointer = privateEnv;
+  // 6. Repeat, while pointer is not null,
+  while (!(pointer instanceof NullValue)) {
+    // a. For each Private Name binding of pointer.[[Names]], do
+    for (const binding of pointer.Names) {
+      // i. If privateIdentifiers does not contain binding.[[Description]], append binding.[[Description]] to privateIdentifiers.
+      privateIdentifiers.push(binding.Description);
+    }
+    // b. Set pointer to pointer.[[OuterPrivateEnvironment]].
+    pointer = pointer.OuterPrivateEnvironment;
+  }
+  // 7. If AllPrivateIdentifiersValid of body with argument privateIdentifiers is false, throw a SyntaxError exception.
+  Assert(true);
+  // 8. Let functionsToInitialize be a new empty List.
+  const functionsToInitialize = [];
+  // 9. Let declaredFunctionNames be a new empty List.
+  const declaredFunctionNames = new JSStringSet();
+  // 10. For each d in varDeclarations, in reverse list order, do
+  for (const d of [...varDeclarations].reverse()) {
+    // a. If d is neither a VariableDeclaration nor a ForBinding nor a BindingIdentifier, then
+    if (d.type !== 'VariableDeclaration'
+        && d.type !== 'ForBinding'
+        && d.type !== 'BindingIdentifier') {
+      // i. Assert: d is either a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration.
+      Assert(d.type === 'FunctionDeclaration'
+             || d.type === 'GeneratorDeclaration'
+             || d.type === 'AsyncFunctionDeclaration'
+             || d.type === 'AsyncGeneratorDeclaration');
+      // ii. NOTE: If there are multiple function declarations for the same name, the last declaration is used.
+      // iii. Let fn be the sole element of the BoundNames of d.
+      const fn = BoundNames(d)[0];
+      // iv. If fn is not an element of declaredFunctionNames, then
+      if (!declaredFunctionNames.has(fn)) {
+        // 1. If varEnv is a global Environment Record, then
+        if (varEnv instanceof GlobalEnvironmentRecord) {
+          // a. Let fnDefinable be ? varEnv.CanDeclareGlobalFunction(fn).
+          const fnDefinable = Q(varEnv.CanDeclareGlobalFunction(fn));
+          // b. Let fnDefinable be ? varEnv.CanDeclareGlobalFunction(fn).
+          if (fnDefinable === Value.false) {
+            return surroundingAgent.Throw('TypeError', 'AlreadyDeclared', fn);
+          }
+        }
+        // 2. Append fn to declaredFunctionNames.
+        declaredFunctionNames.add(fn);
+        // 3. Insert d as the first element of functionsToInitialize.
+        functionsToInitialize.unshift(d);
+      }
+    }
+  }
+  // 11. NOTE: Annex B.3.3.3 adds additional steps at this point.
+  // 12. Let declaredVarNames be a new empty List.
+  const declaredVarNames = new JSStringSet();
+  // 13. For each d in varDeclarations, do
+  for (const d of varDeclarations) {
+    // a. If d is a VariableDeclaration, a ForBinding, or a BindingIdentifier, then
+    if (d.type === 'VariableDeclaration'
+        || d.type === 'ForBinding'
+        || d.type === 'BindingIdentifier') {
+      // i. For each String vn in the BoundNames of d, do
+      for (const vn of BoundNames(d)) {
+        // 1. If vn is not an element of declaredFunctionNames, then
+        if (!declaredFunctionNames.has(vn)) {
+          // a. If varEnv is a global Environment Record, then
+          if (varEnv instanceof GlobalEnvironmentRecord) {
+            // i. Let vnDefinable be ? varEnv.CanDeclareGlobalVar(vn).
+            const vnDefinable = Q(varEnv.CanDeclareGlobalVar(vn));
+            // ii. If vnDefinable is false, throw a TypeError exception.
+            if (vnDefinable === Value.false) {
+              return surroundingAgent.Throw('TypeError', 'AlreadyDeclared', vn);
+            }
+          }
+          // b. If vn is not an element of declaredVarNames, then
+          if (!declaredVarNames.has(vn)) {
+            // i. Append vn to declaredVarNames.
+            declaredVarNames.add(vn);
+          }
+        }
+      }
+    }
+  }
+  // 14. NOTE: No abnormal terminations occur after this algorithm step unless
+  //     varEnv is a global Environment Record and the global object is a Proxy exotic object.
+  // 15. Let lexDeclarations be the LexicallyScopedDeclarations of body.
+  const lexDeclarations = LexicallyScopedDeclarations(body);
+  // 16. For each element d in lexDeclarations, do
+  for (const d of lexDeclarations) {
+    // a. NOTE: Lexically declared names are only instantiated here but not initialized.
+    // b. For each element dn of the BoundNames of d, do
+    for (const dn of BoundNames(d)) {
+      // i. If IsConstantDeclaration of d is true, then
+      if (IsConstantDeclaration(d)) {
+        // 1. Perform ? lexEnv.CreateImmutableBinding(dn, true).
+        Q(lexEnv.CreateImmutableBinding(dn, Value.true));
+      } else { // ii. Else,
+        // 1. Perform ? lexEnv.CreateMutableBinding(dn, false).
+        Q(lexEnv.CreateMutableBinding(dn, Value.false));
+      }
+    }
+  }
+  // 17. For each Parse Node f in functionsToInitialize, do
+  for (const f of functionsToInitialize) {
+    // a. Let fn be the sole element of the BoundNames of f.
+    const fn = BoundNames(f)[0];
+    // b. Let fn be the sole element of the BoundNames of f.
+    const fo = InstantiateFunctionObject(f, lexEnv, privateEnv);
+    // c. If varEnv is a global Environment Record, then
+    if (varEnv instanceof GlobalEnvironmentRecord) {
+      // i. Perform ? varEnv.CreateGlobalFunctionBinding(fn, fo, true).
+      Q(varEnv.CreateGlobalFunctionBinding(fn, fo, Value.true));
+    } else { // d. Else,
+      // i. Let bindingExists be varEnv.HasBinding(fn).
+      const bindingExists = varEnv.HasBinding(fn);
+      // ii. If bindingExists is false, then
+      if (bindingExists === Value.false) {
+        // 1. Let status be ! varEnv.CreateMutableBinding(fn, true).
+        // 2. Assert: status is not an abrupt completion because of validation preceding step 12.
+        X(varEnv.CreateMutableBinding(fn, Value.true));
+        // 3. Perform ! varEnv.InitializeBinding(fn, fo).
+        X(varEnv.InitializeBinding(fn, fo));
+      } else { // iii. Else,
+        // 1. Perform ! varEnv.SetMutableBinding(fn, fo, false).
+        X(varEnv.SetMutableBinding(fn, fo, Value.false));
+      }
+    }
+  }
+  // 18. For each String vn in declaredVarNames, in list order, do
+  for (const vn of declaredVarNames) {
+    // a. If varEnv is a global Environment Record, then
+    if (varEnv instanceof GlobalEnvironmentRecord) {
+      // i. Perform ? varEnv.CreateGlobalVarBinding(vn, true).
+      Q(varEnv.CreateGlobalVarBinding(vn, Value.true));
+    } else { // b. Else,
+      // i. Let bindingExists be varEnv.HasBinding(vn).
+      const bindingExists = varEnv.HasBinding(vn);
+      // ii. If bindingExists is false, then
+      if (bindingExists === Value.false) {
+        // 1. Let status be ! varEnv.CreateMutableBinding(vn, true).
+        // 2. Assert: status is not an abrupt completion because of validation preceding step 12.
+        X(varEnv.CreateMutableBinding(vn, Value.true));
+        // 3. Perform ! varEnv.InitializeBinding(vn, undefined).
+        X(varEnv.InitializeBinding(vn, Value.undefined));
+      }
+    }
+  }
+  // 19. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}