@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/GlobalDeclarationInstantiation.mts

@@ -0,0 +1,140 @@
+import {
+  BoundNames,
+  IsConstantDeclaration,
+  LexicallyDeclaredNames,
+  LexicallyScopedDeclarations,
+  VarDeclaredNames,
+  VarScopedDeclarations,
+} from '../static-semantics/all.mts';
+import { Value } from '../value.mts';
+import { Q, NormalCompletion } from '../completion.mts';
+import { JSStringSet } from '../utils/container.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { InstantiateFunctionObject } from './all.mts';
+import { Assert, GlobalEnvironmentRecord, Throw } from '#self';
+
+export function* GlobalDeclarationInstantiation(script: ParseNode.Script, env: GlobalEnvironmentRecord) {
+  // 2. Let lexNames be the LexicallyDeclaredNames of script.
+  const lexNames = LexicallyDeclaredNames(script);
+  // 3. Let varNames be the VarDeclaredNames of script.
+  const varNames = VarDeclaredNames(script);
+  // 4. For each name in lexNames, do
+  for (const name of lexNames) {
+    // 1. If env.HasLexicalDeclaration(name) is true, throw a SyntaxError exception.
+    if ((yield* env.HasLexicalDeclaration(name)) === Value.true) {
+      return Throw.SyntaxError('$1 is already declared', name);
+    }
+    // 1. Let hasRestrictedGlobal be ? env.HasRestrictedGlobalProperty(name).
+    const hasRestrictedGlobal = Q(yield* env.HasRestrictedGlobalProperty(name));
+    // 1. If hasRestrictedGlobal is true, throw a SyntaxError exception.
+    if (hasRestrictedGlobal === Value.true) {
+      return Throw.SyntaxError('$1 is already declared', name);
+    }
+  }
+  // 5. For each name in varNames, do
+  for (const name of varNames) {
+    // 1. If env.HasLexicalDeclaration(name) is true, throw a SyntaxError exception.
+    if ((yield* env.HasLexicalDeclaration(name)) === Value.true) {
+      return Throw.SyntaxError('$1 is already declared', name);
+    }
+  }
+  // 6. Let varDeclarations be the VarScopedDeclarations of script.
+  const varDeclarations = VarScopedDeclarations(script);
+  // 7. Let functionsToInitialize be a new empty List.
+  const functionsToInitialize = [];
+  // 8. Let declaredFunctionNames be a new empty List.
+  const declaredFunctionNames = new JSStringSet();
+  // 9. 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. Let fnDefinable be ? env.CanDeclareGlobalFunction(fn).
+        const fnDefinable = Q(yield* env.CanDeclareGlobalFunction(fn));
+        // 2. If fnDefinable is false, throw a TypeError exception.
+        if (fnDefinable === Value.false) {
+          return Throw.TypeError('$1 is already declared', fn);
+        }
+        // 3. Append fn to declaredFunctionNames.
+        declaredFunctionNames.add(fn);
+        // 4. Insert d as the first element of functionsToInitialize.
+        functionsToInitialize.unshift(d);
+      }
+    }
+  }
+  // 10. Let declaredVarNames be a new empty List.
+  const declaredVarNames = new JSStringSet();
+  // 11. 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. Let vnDefinable be ? env.CanDeclareGlobalVar(vn).
+          const vnDefinable = Q(yield* env.CanDeclareGlobalVar(vn));
+          // b. If vnDefinable is false, throw a TypeError exception.
+          if (vnDefinable === Value.false) {
+            return Throw.TypeError('$1 is already declared', vn);
+          }
+          // c. If vn is not an element of declaredVarNames, then
+          if (!declaredVarNames.has(vn)) {
+            // i. Append vn to declaredVarNames.
+            declaredVarNames.add(vn);
+          }
+        }
+      }
+    }
+  }
+  // 12. NOTE: No abnormal terminations occur after this algorithm step if the global object is an ordinary object. However, if the global object is a Proxy exotic object it may exhibit behaviours that cause abnormal terminations in some of the following steps.
+  // 13. NOTE: Annex B.3.3.2 adds additional steps at this point.
+  // 14. Let lexDeclarations be the LexicallyScopedDeclarations of script.
+  const lexDeclarations = LexicallyScopedDeclarations(script);
+  // 15. Let privateEnv be null.
+  const privateEnv = null;
+  // 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)) {
+      // 1. If IsConstantDeclaration of d is true, then
+      if (IsConstantDeclaration(d)) {
+        // 1. Perform ? env.CreateImmutableBinding(dn, true).
+        Q(env.CreateImmutableBinding(dn, Value.true));
+      } else { // 1. Else,
+        // 1. Perform ? env.CreateMutableBinding(dn, false).
+        Q(yield* env.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 fo be InstantiateFunctionObject of f with argument env and privateEnv.
+    const fo = InstantiateFunctionObject(f, env, privateEnv);
+    // c. Perform ? env.CreateGlobalFunctionBinding(fn, fo, false).
+    Q(yield* env.CreateGlobalFunctionBinding(fn, fo, Value.false));
+  }
+  // 18. For each String vn in declaredVarNames, in list order, do
+  for (const vn of declaredVarNames) {
+    // a. Perform ? env.CreateGlobalVarBinding(vn, false).
+    Q(yield* env.CreateGlobalVarBinding(vn, Value.false));
+  }
+  // 19. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/HoistableDeclaration.mts

@@ -0,0 +1,12 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation */
+//   HoistableDeclaration :
+//     GeneratorDeclaration
+//     AsyncFunctionDeclaration
+//     AsyncGeneratorDeclaration
+export function Evaluate_HoistableDeclaration(_HoistableDeclaration: ParseNode.HoistableDeclaration) {
+  // 1. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/IdentifierReference.mts

@@ -0,0 +1,15 @@
+import { StringValue } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ReferenceRecord } from '../value.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import { ResolveBinding } from '#self';
+
+/** https://tc39.es/ecma262/#sec-identifiers-runtime-semantics-evaluation */
+// IdentifierReference :
+//   Identifier
+//   `yield`
+//   `await`
+export function* Evaluate_IdentifierReference(IdentifierReference: ParseNode.IdentifierReference): PlainEvaluator<ReferenceRecord> {
+  // 1. Return ? ResolveBinding(StringValue of Identifier).
+  return yield* ResolveBinding(StringValue(IdentifierReference), undefined, IdentifierReference.strict);
+}

package/src/runtime-semantics/IfStatement.mts

@@ -0,0 +1,49 @@
+import { Evaluate } from '../evaluator.mts';
+import {
+  Completion,
+  EnsureCompletion,
+  NormalCompletion,
+  Q,
+  UpdateEmpty,
+} from '../completion.mts';
+import { Value } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  GetValue,
+  ToBoolean,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-if-statement-runtime-semantics-evaluation */
+// IfStatement :
+//   `if` `(` Expression `)` Statement `else` Statement
+//   `if` `(` Expression `)` Statement
+export function* Evaluate_IfStatement({ Expression, Statement_a, Statement_b }: ParseNode.IfStatement) {
+  // 1. Let exprRef be the result of evaluating Expression.
+  const exprRef = Q(yield* Evaluate(Expression));
+  // 2. Let exprValue be ! ToBoolean(? GetValue(exprRef)).
+  const exprValue = ToBoolean(Q(yield* GetValue(exprRef)));
+  if (Statement_b) {
+    let stmtCompletion;
+    // 3. If exprValue is true, then
+    if (exprValue === Value.true) {
+      // a. Let stmtCompletion be the result of evaluating the first Statement.
+      stmtCompletion = yield* Evaluate(Statement_a);
+    } else { // 4. Else,
+      // a. Let stmtCompletion be the result of evaluating the second Statement.
+      stmtCompletion = yield* Evaluate(Statement_b);
+    }
+    // 5. Return Completion(UpdateEmpty(stmtCompletion, undefined)).
+    return Completion(UpdateEmpty(EnsureCompletion(stmtCompletion), Value.undefined));
+  } else {
+    // 3. If exprValue is false, then
+    if (exprValue === Value.false) {
+      // a. Return NormalCompletion(undefined).
+      return NormalCompletion(Value.undefined);
+    } else { // 4. Else,
+      // a. Let stmtCompletion be the result of evaluating Statement.
+      const stmtCompletion = yield* Evaluate(Statement_a);
+      // b. Return Completion(UpdateEmpty(stmtCompletion, undefined)).
+      return Completion(UpdateEmpty(EnsureCompletion(stmtCompletion), Value.undefined));
+    }
+  }
+}

package/src/runtime-semantics/ImportCall.mts

@@ -0,0 +1,137 @@
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import {
+  Q, X, IfAbruptRejectPromise,
+} from '../completion.mts';
+import {
+  AbstractModuleRecord, AllImportAttributesSupported, Call, CyclicModuleRecord, EnumerableOwnProperties, Get, JSStringValue, NullValue, ObjectValue, Realm, Value, type ImportAttributeRecord, type ModuleRequestRecord, type PromiseObject, type ScriptRecord,
+} from '../index.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { __ts_cast__ } from '../utils/language.mts';
+import {
+  surroundingAgent, HostLoadImportedModule,
+  GetValue,
+  ToString,
+  NewPromiseCapability,
+  GetActiveScriptOrModule,
+  Throw,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-import-calls */
+// ImportCall : `import` `(` AssignmentExpression `)`
+export function* Evaluate_ImportCall(ImportCall: ParseNode.ImportCall): ValueEvaluator<PromiseObject> {
+  Q(surroundingAgent.debugger_cannotPreview);
+  return yield* EvaluateImportCall(ImportCall.AssignmentExpression, ImportCall.Phase, ImportCall.OptionsExpression);
+}
+
+/** https://tc39.es/ecma262/#sec-evaluate-import-call */
+function* EvaluateImportCall(
+  specifiersExpression: ParseNode.AssignmentExpressionOrHigher,
+  phase: 'source' | 'defer' | 'evaluation',
+  optionsExpression: undefined | ParseNode.AssignmentExpressionOrHigher,
+): ValueEvaluator<PromiseObject> {
+  // 1. Let referrer be ! GetActiveScriptOrModule().
+  let referrer: NullValue | AbstractModuleRecord | ScriptRecord | Realm = X(GetActiveScriptOrModule());
+  // 2. If referrer is null, set referrer to the current Realm Record.
+  if (referrer instanceof NullValue) {
+    referrer = surroundingAgent.currentRealmRecord;
+  }
+  // 3. Let specifierRef be ? Evaluation of AssignmentExpression.
+  const specifierRef = Q(yield* Evaluate(specifiersExpression));
+  // 4. Let specifier be ? GetValue(specifierRef).
+  const specifier = Q(yield* GetValue(specifierRef));
+  let options: Value;
+  // 5. If optionsExpression is present, then
+  if (optionsExpression) {
+    // a. Let optionsRef be ? Evaluation of optionsExpression.
+    const optionsRef = Q(yield* Evaluate(optionsExpression));
+    // b. Let options be ? GetValue(optionsRef).
+    options = Q(yield* GetValue(optionsRef));
+  } else { // 6. Else,
+    // a. Let options be undefined.
+    options = Value.undefined;
+  }
+  // 7. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 8. Let specifierString be ToString(specifier).
+  const specifierString = yield* ToString(specifier);
+  // 9. IfAbruptRejectPromise(specifierString, promiseCapability).
+  IfAbruptRejectPromise(specifierString, promiseCapability);
+  __ts_cast__<JSStringValue>(specifierString);
+  // 10. Let attributes nw a new empty List.
+  const attributes: ImportAttributeRecord[] = [];
+  // 11. If options is not undefined, then
+  if (options !== Value.undefined) {
+    // a. If options is not an Object, then
+    if (!(options instanceof ObjectValue)) {
+      // i. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
+      X(Call(promiseCapability.Reject, Value.undefined, [
+        Throw.TypeError('The second argument to import() must be an object, but $1', options).Value,
+      ]));
+      // ii. Return promiseCapability.[[Promise]].
+      return promiseCapability.Promise;
+    }
+    // b. Let attributesObj be Completion(Get(options, "with")).
+    const attributesObj = yield* Get(options, Value('with'));
+    // c. IfAbruptRejectPromise(attributesObj, promiseCapability).
+    IfAbruptRejectPromise(attributesObj, promiseCapability);
+    __ts_cast__<Value>(attributesObj);
+    // d. If attributesObj is not undefined, then
+    if (attributesObj !== Value.undefined) {
+      // i. If attributesObj is not an Object, then
+      if (!(attributesObj instanceof ObjectValue)) {
+        // 1. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
+        X(Call(promiseCapability.Reject, Value.undefined, [
+          Throw.TypeError('The "with" option in import() must be an object, but $1', attributesObj).Value,
+        ]));
+        // 2. Return promiseCapability.[[Promise]].
+        return promiseCapability.Promise;
+      }
+      // ii. Let entries be Completion(EnumerableOwnProperties(attributesObj, key+value)).
+      const entries = yield* EnumerableOwnProperties(attributesObj, 'key+value');
+      // iii. IfAbruptRejectPromise(entries, promiseCapability).
+      IfAbruptRejectPromise(entries, promiseCapability);
+      __ts_cast__<ObjectValue[]>(entries);
+      // iv. For each element entry of entries, do
+      for (const entry of entries) {
+        // 1. Let key be ! Get(entry, "0").
+        const key = Q(yield* Get(entry, Value('0')));
+        // 2. Let value be ! Get(entry, "1").
+        const value = Q(yield* Get(entry, Value('1')));
+        // 3. If key is a String, then
+        if (key instanceof JSStringValue) {
+          // a. If value is not a String, then
+          if (!(value instanceof JSStringValue)) {
+            // i. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
+            X(Call(promiseCapability.Reject, Value.undefined, [
+              Throw.TypeError('Import attribute value must be a string, but $1', value).Value,
+            ]));
+            // ii. Return promiseCapability.[[Promise]].
+            return promiseCapability.Promise;
+          }
+          // b. Append the ImportAttribute Record { [[Key]]: key, [[Value]]: value } to attributes.
+          attributes.push({ Key: key.value, Value: value.value });
+        }
+      }
+      // e. If AllImportAttributesSupported(attributes) is false, then
+      const unsupportedAttributeKey = AllImportAttributesSupported(attributes);
+      if (unsupportedAttributeKey) {
+        // i. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
+        X(Call(promiseCapability.Reject, Value.undefined, [
+          Throw.TypeError('Unsupported import attribute "$1"', unsupportedAttributeKey).Value,
+        ]));
+        // ii. Return promiseCapability.[[Promise]].
+        return promiseCapability.Promise;
+      }
+      // f. Sort attributes according to the lexicographic order of their [[Key]] field, treating the value of each such field as a sequence of UTF-16 code unit values.
+      attributes.sort((a, b) => (a.Key < b.Key ? -1 : 1));
+    }
+  }
+  // 12. Let moduleRequest be a new ModuleRequest Record { [[Specifier]]: specifierString, [[Attributes]]: attributes }.
+  const moduleRequest: ModuleRequestRecord = {
+    Specifier: specifierString.value, Attributes: attributes, Phase: phase, ImportedNames: 'all',
+  };
+  // 10. Perform HostLoadImportedModule(referrer, specifierString, ~empty~, promiseCapability).
+  HostLoadImportedModule(referrer as CyclicModuleRecord | ScriptRecord | Realm, moduleRequest, undefined, { data: promiseCapability });
+  // 9. Return promiseCapability.[[Promise]].
+  return promiseCapability.Promise;
+}

package/src/runtime-semantics/ImportDeclaration.mts

@@ -0,0 +1,9 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-module-semantics-runtime-semantics-evaluation */
+// ModuleItem : ImportDeclaration
+export function Evaluate_ImportDeclaration(_ImportDeclaration: ParseNode.ImportDeclaration) {
+  // 1. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/ImportMeta.mts

@@ -0,0 +1,45 @@
+import { HostGetImportMetaProperties, HostFinalizeImportMeta } from '../host-defined/engine.mts';
+import { ObjectValue, Value } from '../value.mts';
+import { X } from '../completion.mts';
+import { SourceTextModuleRecord } from '../modules.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Assert,
+  GetActiveScriptOrModule,
+  OrdinaryObjectCreate,
+  CreateDataPropertyOrThrow,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-meta-properties */
+//   ImportMeta : `import` `.` `meta`
+export function Evaluate_ImportMeta(_ImportMeta: ParseNode.ImportMeta) {
+  // 1. Let module be ! GetActiveScriptOrModule().
+  const module = X(GetActiveScriptOrModule());
+  // 2. Assert: module is a Source Text Module Record.
+  Assert(module instanceof SourceTextModuleRecord);
+  // 3. Let importMeta be module.[[ImportMeta]].
+  let importMeta = module.ImportMeta;
+  // 4. If importMeta is empty, then
+  if (importMeta === undefined) {
+    // a. Set importMeta to ! OrdinaryObjectCreate(null).
+    importMeta = X(OrdinaryObjectCreate(Value.null));
+    // b. Let importMetaValues be ! HostGetImportMetaProperties(module).
+    const importMetaValues = X(HostGetImportMetaProperties(module));
+    // c. For each Record { [[Key]], [[Value]] } p that is an element of importMetaValues, do
+    for (const p of importMetaValues) {
+      // i. Perform ! CreateDataPropertyOrThrow(importMeta, p.[[Key]], p.[[Value]]).
+      X(CreateDataPropertyOrThrow(importMeta, p.Key, p.Value));
+    }
+    // d. Perform ! HostFinalizeImportMeta(importMeta, module).
+    X(HostFinalizeImportMeta(importMeta, module));
+    // e. Set module.[[ImportMeta]] to importMeta.
+    module.ImportMeta = importMeta;
+    // f. Return importMeta.
+    return importMeta;
+  } else { // 5. Else,
+    // a. Assert: Type(importMeta) is Object.
+    Assert(importMeta instanceof ObjectValue);
+    // b. Return importMeta.
+    return importMeta;
+  }
+}

package/src/runtime-semantics/InstantiateArrowFunctionExpression.mts

@@ -0,0 +1,36 @@
+import { Value } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  surroundingAgent, OrdinaryFunctionCreate, SetFunctionName, sourceTextMatchedBy,
+} from '#self';
+import type { PrivateName, PropertyKeyValue } from '#self';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiatearrowfunctionexpression */
+// ArrowFunction : ArrowParameters `=>` ConciseBody
+export function InstantiateArrowFunctionExpression(ArrowFunction: ParseNode.ArrowFunction, name?: PropertyKeyValue | PrivateName) {
+  const { ArrowParameters, ConciseBody } = ArrowFunction;
+  // 1. If name is not present, set name to "".
+  if (name === undefined) {
+    name = Value('');
+  }
+  // 2. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 3. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 4. Let sourceText be the source text matched by ArrowFunction.
+  const sourceText = sourceTextMatchedBy(ArrowFunction);
+  // 5. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, ArrowParameters, ConciseBody, lexical-this, scope, privateScope).
+  const closure = OrdinaryFunctionCreate(
+    surroundingAgent.intrinsic('%Function.prototype%'),
+    sourceText,
+    ArrowParameters,
+    ConciseBody,
+    'lexical-this',
+    scope,
+    privateScope,
+  );
+  // 6. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 7. Return closure.
+  return closure;
+}

package/src/runtime-semantics/InstantiateAsyncArrowFunctionExpression.mts

@@ -0,0 +1,38 @@
+import { Value } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  surroundingAgent, OrdinaryFunctionCreate, SetFunctionName, sourceTextMatchedBy,
+} from '#self';
+import type { PrivateName, PropertyKeyValue } from '#self';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiateasyncarrowfunctionexpression */
+// AsyncArrowFunction : ArrowParameters `=>` AsyncConciseBody
+export function InstantiateAsyncArrowFunctionExpression(AsyncArrowFunction: ParseNode.AsyncArrowFunction, name?: PropertyKeyValue | PrivateName) {
+  const { ArrowParameters, AsyncConciseBody } = AsyncArrowFunction;
+  // 1. If name is not present, set name to "".
+  if (name === undefined) {
+    name = Value('');
+  }
+  // 2. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 3. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 4. Let sourceText be the source text matched by AsyncArrowFunction.
+  const sourceText = sourceTextMatchedBy(AsyncArrowFunction);
+  // 5. Let parameters be AsyncArrowBindingIdentifier.
+  const parameters = ArrowParameters;
+  // 6. Let closure be OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, ArrowParameters, AsyncConciseBody, lexical-this, scope, privateScope).
+  const closure = OrdinaryFunctionCreate(
+    surroundingAgent.intrinsic('%AsyncFunction.prototype%'),
+    sourceText,
+    parameters,
+    AsyncConciseBody,
+    'lexical-this',
+    scope,
+    privateScope,
+  );
+  // 7. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 8. Return closure.
+  return closure;
+}

package/src/runtime-semantics/InstantiateAsyncFunctionExpression.mts

@@ -0,0 +1,75 @@
+import {
+  PrivateName, Value, type PropertyKeyValue,
+} from '../value.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  surroundingAgent,
+  Assert,
+  OrdinaryFunctionCreate,
+  SetFunctionName,
+  sourceTextMatchedBy,
+  DeclarativeEnvironmentRecord,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiateasyncfunctionexpression */
+export function InstantiateAsyncFunctionExpression(AsyncFunctionExpression: ParseNode.AsyncFunctionExpression, name?: PropertyKeyValue | PrivateName) {
+  const { BindingIdentifier, FormalParameters, AsyncBody } = AsyncFunctionExpression;
+  if (BindingIdentifier) {
+    // 1. Assert: name is not present.
+    Assert(name === undefined);
+    // 2. Set name to StringValue of BindingIdentifier.
+    name = StringValue(BindingIdentifier);
+    // 3. Let scope be the LexicalEnvironment of the running execution context.
+    const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+    // 4. Let funcEnv be ! NewDeclarativeEnvironment(scope).
+    const funcEnv = X(new DeclarativeEnvironmentRecord(scope));
+    // 5. Perform ! funcEnv.CreateImmutableBinding(name, false).
+    X(funcEnv.CreateImmutableBinding(name, Value.false));
+    // 6. Let privateScope be the running execution context's PrivateEnvironment.
+    const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+    // 7. Let sourceText be the source text matched by AsyncFunctionExpression.
+    const sourceText = sourceTextMatchedBy(AsyncFunctionExpression);
+    // 8. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, FormalParameters, AsyncBody, non-lexical-this, funcEnv, privateScope).
+    const closure = X(OrdinaryFunctionCreate(
+      surroundingAgent.intrinsic('%AsyncFunction.prototype%'),
+      sourceText,
+      FormalParameters,
+      AsyncBody,
+      'non-lexical-this',
+      funcEnv,
+      privateScope,
+    ));
+    // 9. Perform ! SetFunctionName(closure, name).
+    X(SetFunctionName(closure, name));
+    // 10. Perform ! funcEnv.InitializeBinding(name, closure).
+    X(funcEnv.InitializeBinding(name, closure));
+    // 11. Return closure.
+    return closure;
+  }
+  // 1. If name is not present, set name to "".
+  if (name === undefined) {
+    name = Value('');
+  }
+  // 2. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 3. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 4. Let sourceText be the source text matched by AsyncFunctionExpression.
+  const sourceText = sourceTextMatchedBy(AsyncFunctionExpression);
+  // 5. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, FormalParameters, AsyncBody, non-lexical-this, scope, privateScope).
+  const closure = X(OrdinaryFunctionCreate(
+    surroundingAgent.intrinsic('%AsyncFunction.prototype%'),
+    sourceText,
+    FormalParameters,
+    AsyncBody,
+    'non-lexical-this',
+    scope,
+    privateScope,
+  ));
+  // 6. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 7. Return closure.
+  return closure;
+}

package/src/runtime-semantics/InstantiateAsyncGeneratorFunctionExpression.mts

@@ -0,0 +1,90 @@
+import {
+  Value, Descriptor, type PropertyKeyValue, PrivateName,
+} from '../value.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  surroundingAgent,
+  Assert,
+  DefinePropertyOrThrow,
+  OrdinaryFunctionCreate,
+  OrdinaryObjectCreate,
+  SetFunctionName,
+  sourceTextMatchedBy,
+  DeclarativeEnvironmentRecord,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiateasyncgeneratorfunctionexpression */
+//   AsyncGeneratorExpression :
+//     `async` `function` `*` `(` FormalParameters `)` `{` AsyncGeneratorBody `}`
+//     `async` `function` `*` BindingIdentifier `(` FormalParameters `)` `{` AsyncGeneratorBody `}`
+export function InstantiateAsyncGeneratorFunctionExpression(AsyncGeneratorExpression: ParseNode.AsyncGeneratorExpression, name?: PropertyKeyValue | PrivateName) {
+  const { BindingIdentifier, FormalParameters, AsyncGeneratorBody } = AsyncGeneratorExpression;
+  if (BindingIdentifier) {
+    // 1. Assert: name is not present.
+    Assert(name === undefined);
+    // 2. Set name to StringValue of BindingIdentifier.
+    name = StringValue(BindingIdentifier);
+    // 3. Let scope be the running execution context's LexicalEnvironment.
+    const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+    // 4. Let funcEnv be NewDeclarativeEnvironment(scope).
+    const funcEnv = new DeclarativeEnvironmentRecord(scope);
+    // 5. Perform funcEnv.CreateImmutableBinding(name, false).
+    funcEnv.CreateImmutableBinding(name, Value.false);
+    // 6. Let privateScope be the running execution context's PrivateEnvironment.
+    const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+    // 7. Let source text be the source textmatched by AsyncGeneratorExpression.
+    const sourceText = sourceTextMatchedBy(AsyncGeneratorExpression);
+    // 8. Let closure be OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, FormalParameters, AsyncGeneratorBody, non-lexical-this, funcEnv, privateScope).
+    const closure = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype%'), sourceText, FormalParameters, AsyncGeneratorBody, 'non-lexical-this', funcEnv, privateScope));
+    // 9. Perform SetFunctionName(closure, name).
+    SetFunctionName(closure, name);
+    // 10. Let prototype be OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
+    const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype.prototype%'));
+    // 11. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+    X(DefinePropertyOrThrow(
+      closure,
+      Value('prototype'),
+      Descriptor({
+        Value: prototype,
+        Writable: Value.true,
+        Enumerable: Value.false,
+        Configurable: Value.false,
+      }),
+    ));
+    // 12. Perform funcEnv.InitializeBinding(name, closure).
+    X(funcEnv.InitializeBinding(name, closure));
+    // 13. Return closure.
+    return closure;
+  }
+  // 1. If name is not present, set name to "".
+  if (name === undefined) {
+    name = Value('');
+  }
+  // 2. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 3. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 4. Let sourceText be the source text matched by AsyncGeneratorExpression.
+  const sourceText = sourceTextMatchedBy(AsyncGeneratorExpression);
+  // 5. Let closure be ! OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, FormalParameters, AsyncGeneratorBody, non-lexical-this, scope, privateScope).
+  const closure = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype%'), sourceText, FormalParameters, AsyncGeneratorBody, 'non-lexical-this', scope, privateScope));
+  // 6. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 7. Let prototype be ! OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
+  const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype.prototype%'));
+  // 8. Perform ! DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(
+    closure,
+    Value('prototype'),
+    Descriptor({
+      Value: prototype,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+    }),
+  ));
+  // 9. Return closure.
+  return closure;
+}