@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/runtime-semantics/ImportCall.mts

@@ -0,0 +1,43 @@
+import { surroundingAgent, HostLoadImportedModule } from '../engine.mts';
+import { Evaluate, type ExpressionEvaluator } from '../evaluator.mts';
+import {
+  GetValue,
+  ToString,
+  NewPromiseCapability,
+  GetActiveScriptOrModule,
+} from '../abstract-ops/all.mts';
+import {
+  Q, X, IfAbruptRejectPromise,
+} from '../completion.mts';
+import {
+  AbstractModuleRecord, CyclicModuleRecord, JSStringValue, NullValue, Realm, type PromiseObject, type ScriptRecord,
+} from '../api.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { __ts_cast__ } from '../helpers.mts';
+
+/** https://tc39.es/ecma262/#sec-import-calls */
+// ImportCall : `import` `(` AssignmentExpression `)`
+export function* Evaluate_ImportCall({ AssignmentExpression }: ParseNode.ImportCall): ExpressionEvaluator<PromiseObject> {
+  Q(surroundingAgent.debugger_cannotPreview);
+  // 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 argRef be the result of evaluating AssignmentExpression.
+  const argRef = yield* Evaluate(AssignmentExpression);
+  // 4. Let specifier be ? GetValue(argRef).
+  const specifier = Q(GetValue(argRef));
+  // 5. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 6. Let specifierString be ToString(specifier).
+  const specifierString = ToString(specifier);
+  // 7. IfAbruptRejectPromise(specifierString, promiseCapability).
+  IfAbruptRejectPromise(specifierString, promiseCapability);
+  __ts_cast__<JSStringValue>(specifierString);
+  // 8. Perform HostLoadImportedModule(referrer, specifierString, ~empty~, promiseCapability).
+  HostLoadImportedModule(referrer as CyclicModuleRecord | ScriptRecord | Realm, specifierString, undefined, 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 '../engine.mts';
+import { ObjectValue, Value } from '../value.mts';
+import {
+  Assert,
+  GetActiveScriptOrModule,
+  OrdinaryObjectCreate,
+  CreateDataPropertyOrThrow,
+} from '../abstract-ops/all.mts';
+import { X } from '../completion.mts';
+import { SourceTextModuleRecord } from '../modules.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** 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,35 @@
+import { surroundingAgent } from '../engine.mts';
+import { Value } from '../value.mts';
+import { OrdinaryFunctionCreate, SetFunctionName, sourceTextMatchedBy } from '../abstract-ops/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+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,37 @@
+import { surroundingAgent } from '../engine.mts';
+import { Value } from '../value.mts';
+import { OrdinaryFunctionCreate, SetFunctionName, sourceTextMatchedBy } from '../abstract-ops/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+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 { surroundingAgent } from '../engine.mts';
+import {
+  PrivateName, Value, type PropertyKeyValue,
+} from '../value.mts';
+import {
+  Assert,
+  OrdinaryFunctionCreate,
+  SetFunctionName,
+  sourceTextMatchedBy,
+} from '../abstract-ops/all.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { X } from '../completion.mts';
+import { DeclarativeEnvironmentRecord } from '../environment.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** 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 { surroundingAgent } from '../engine.mts';
+import {
+  Value, Descriptor, type PropertyKeyValue, PrivateName,
+} from '../value.mts';
+import {
+  Assert,
+  DefinePropertyOrThrow,
+  OrdinaryFunctionCreate,
+  OrdinaryObjectCreate,
+  SetFunctionName,
+  sourceTextMatchedBy,
+} from '../abstract-ops/all.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { X } from '../completion.mts';
+import { DeclarativeEnvironmentRecord } from '../environment.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** 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).
+    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;
+}

package/src/runtime-semantics/InstantiateFunctionObject.mts

@@ -0,0 +1,123 @@
+import {
+  DefinePropertyOrThrow,
+  MakeConstructor,
+  OrdinaryObjectCreate,
+  SetFunctionName,
+  OrdinaryFunctionCreate,
+  sourceTextMatchedBy,
+} from '../abstract-ops/all.mts';
+import { X } from '../completion.mts';
+import { surroundingAgent } from '../engine.mts';
+import { OutOfRange } from '../helpers.mts';
+import { Descriptor, Value } from '../value.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { EnvironmentRecord, NullValue, PrivateEnvironmentRecord } from '#self';
+
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-instantiatefunctionobject */
+//   FunctionDeclaration :
+//     `function` BindingIdentifier `(` FormalParameters `)` `{` FunctionBody `}`
+//     `function` `(` FormalParameters `)` `{` FunctionBody `}`
+export function InstantiateFunctionObject_FunctionDeclaration(FunctionDeclaration: ParseNode.FunctionDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue) {
+  const { BindingIdentifier, FormalParameters, FunctionBody } = FunctionDeclaration;
+  // 1. Let name be StringValue of BindingIdentifier.
+  const name = BindingIdentifier ? StringValue(BindingIdentifier) : Value('default');
+  // 2. Let sourceText be the source text matched by FunctionDeclaration.
+  const sourceText = sourceTextMatchedBy(FunctionDeclaration);
+  // 3. Let F be OrdinaryFunctionCreate(%Function.prototype%, sourceText, FormalParameters, FunctionBody, non-lexical-this, scope, privateScope).
+  const F = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%Function.prototype%'), sourceText, FormalParameters, FunctionBody, 'non-lexical-this', env, privateEnv));
+  // 4. Perform SetFunctionName(F, name).
+  SetFunctionName(F, name);
+  // 5. Perform MakeConstructor(F).
+  MakeConstructor(F);
+  // 6. Return F.
+  return F;
+}
+
+/** https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-instantiatefunctionobject */
+//   GeneratorDeclaration :
+//     `function` `*` BindingIdentifier `(` FormalParameters `)` `{` GeneratorBody `}`
+//     `function` `*` `(` FormalParameters `)` `{` GeneratorBody `}`
+export function InstantiateFunctionObject_GeneratorDeclaration(GeneratorDeclaration: ParseNode.GeneratorDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue) {
+  const { BindingIdentifier, FormalParameters, GeneratorBody } = GeneratorDeclaration;
+  // 1. Let name be StringValue of BindingIdentifier.
+  const name = BindingIdentifier ? StringValue(BindingIdentifier) : Value('default');
+  // 2. Let sourceText be the source text matched by GeneratorDeclaration.
+  const sourceText = sourceTextMatchedBy(GeneratorDeclaration);
+  // 3. Let F be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, FormalParameters, GeneratorBody, non-lexical-this, scope, privateScope).
+  const F = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype%'), sourceText, FormalParameters, GeneratorBody, 'non-lexical-this', env, privateEnv));
+  // 4. Perform SetFunctionName(F, name).
+  SetFunctionName(F, name);
+  // 5. Let prototype be OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
+  const prototype = X(OrdinaryObjectCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype%')));
+  // 6. Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(F, Value('prototype'), Descriptor({
+    Value: prototype,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  // 7. Return F.
+  return F;
+}
+
+/** https://tc39.es/ecma262/#sec-async-function-definitions-InstantiateFunctionObject */
+//  AsyncFunctionDeclaration :
+//    `async` `function` BindingIdentifier `(` FormalParameters `)` `{` AsyncBody `}`
+//    `async` `function` `(` FormalParameters `)` `{` AsyncBody `}`
+export function InstantiateFunctionObject_AsyncFunctionDeclaration(AsyncFunctionDeclaration: ParseNode.AsyncFunctionDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue) {
+  const { BindingIdentifier, FormalParameters, AsyncBody } = AsyncFunctionDeclaration;
+  // 1. Let name be StringValue of BindingIdentifier.
+  const name = BindingIdentifier ? StringValue(BindingIdentifier) : Value('default');
+  // 2. Let sourceText be the source text matched by AsyncFunctionDeclaration.
+  const sourceText = sourceTextMatchedBy(AsyncFunctionDeclaration);
+  // 3. Let F be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, FormalParameters, AsyncBody, non-lexical-this, scope, privateScope).
+  const F = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncFunction.prototype%'), sourceText, FormalParameters, AsyncBody, 'non-lexical-this', env, privateEnv));
+  // 4. Perform ! SetFunctionName(F, name).
+  SetFunctionName(F, name);
+  // 5. Return F.
+  return F;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgenerator-definitions-evaluatebody */
+//  AsyncGeneratorDeclaration :
+//    `async` `function` `*` BindingIdentifier `(` FormalParameters`)` `{` AsyncGeneratorBody `}`
+//    `async` `function` `*` `(` FormalParameters`)` `{` AsyncGeneratorBody `}`
+export function InstantiateFunctionObject_AsyncGeneratorDeclaration(AsyncGeneratorDeclaration: ParseNode.AsyncGeneratorDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue) {
+  const { BindingIdentifier, FormalParameters, AsyncGeneratorBody } = AsyncGeneratorDeclaration;
+  // 1. Let name be StringValue of BindingIdentifier.
+  const name = BindingIdentifier ? StringValue(BindingIdentifier) : Value('default');
+  // 2. Let sourceText be the source text matched by AsyncGeneratorDeclaration.
+  const sourceText = sourceTextMatchedBy(AsyncGeneratorDeclaration);
+  // 3. Let F be ! OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, FormalParameters, AsyncGeneratorBody, non-lexical-this, scope, privateScope).
+  const F = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype%'), sourceText, FormalParameters, AsyncGeneratorBody, 'non-lexical-this', env, privateEnv));
+  // 4. Perform ! SetFunctionName(F, name).
+  SetFunctionName(F, name);
+  // 5. Let prototype be ! OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
+  const prototype = X(OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype.prototype%')));
+  // 6. Perform ! DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(F, Value('prototype'), Descriptor({
+    Value: prototype,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  // 7. Return F.
+  return F;
+}
+
+export function InstantiateFunctionObject(AnyFunctionDeclaration: ParseNode.FunctionDeclaration | ParseNode.GeneratorDeclaration | ParseNode.AsyncFunctionDeclaration | ParseNode.AsyncGeneratorDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue) {
+  switch (AnyFunctionDeclaration.type) {
+    case 'FunctionDeclaration':
+      return InstantiateFunctionObject_FunctionDeclaration(AnyFunctionDeclaration, env, privateEnv);
+    case 'GeneratorDeclaration':
+      return InstantiateFunctionObject_GeneratorDeclaration(AnyFunctionDeclaration, env, privateEnv);
+    case 'AsyncFunctionDeclaration':
+      return InstantiateFunctionObject_AsyncFunctionDeclaration(AnyFunctionDeclaration, env, privateEnv);
+    case 'AsyncGeneratorDeclaration':
+      return InstantiateFunctionObject_AsyncGeneratorDeclaration(AnyFunctionDeclaration, env, privateEnv);
+
+    default:
+      throw new OutOfRange('InstantiateFunctionObject', AnyFunctionDeclaration);
+  }
+}

package/src/runtime-semantics/InstantiateGeneratorFunctionExpression.mts

@@ -0,0 +1,82 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Value, Descriptor, type PropertyKeyValue, PrivateName,
+} from '../value.mts';
+import {
+  Assert,
+  DefinePropertyOrThrow,
+  OrdinaryFunctionCreate,
+  OrdinaryObjectCreate,
+  SetFunctionName,
+  sourceTextMatchedBy,
+} from '../abstract-ops/all.mts';
+import { X } from '../completion.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { DeclarativeEnvironmentRecord } from '../environment.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiategeneratorfunctionexpression */
+//   GeneratorExpression :
+//     `function` `*` `(` FormalParameters `)` `{` GeneratorBody `}`
+//     `function` `* `BindingIdentifier `(` FormalParameters `)` `{` GeneratorBody `}`
+export function InstantiateGeneratorFunctionExpression(GeneratorExpression: ParseNode.GeneratorExpression, name?: PropertyKeyValue | PrivateName) {
+  const { BindingIdentifier, FormalParameters, GeneratorBody } = GeneratorExpression;
+  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 sourceText be the source text matched by GeneratorExpression.
+    const sourceText = sourceTextMatchedBy(GeneratorExpression);
+    // 8. Let closure be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, FormalParameters, GeneratorBody, non-lexical-this, funcEnv, privateScope).
+    const closure = OrdinaryFunctionCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype%'), sourceText, FormalParameters, GeneratorBody, 'non-lexical-this', funcEnv, privateScope);
+    // 9. Perform SetFunctionName(closure, name).
+    SetFunctionName(closure, name);
+    // 10. Let prototype be ! OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
+    const prototype = X(OrdinaryObjectCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype%')));
+    // 11. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+    DefinePropertyOrThrow(closure, Value('prototype'), new Descriptor({
+      Value: prototype,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+    }));
+    // 12. Perform funcEnv.InitializeBinding(name, closure).
+    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 running execution context's LexicalEnvironment.
+  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 GeneratorExpression.
+  const sourceText = sourceTextMatchedBy(GeneratorExpression);
+  // 5. Let closure be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, FormalParameters, GeneratorBody, non-lexical-this, scope, privateScope).
+  const closure = OrdinaryFunctionCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype%'), sourceText, FormalParameters, GeneratorBody, 'non-lexical-this', scope, privateScope);
+  // 6. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 7. Let prototype be ! OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
+  const prototype = X(OrdinaryObjectCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype%')));
+  // 8. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  DefinePropertyOrThrow(closure, Value('prototype'), new Descriptor({
+    Value: prototype,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  }));
+  // 9. Return closure.
+  return closure;
+}

package/src/runtime-semantics/InstantiateOrdinaryFunctionExpression.mts

@@ -0,0 +1,64 @@
+import { surroundingAgent } from '../engine.mts';
+import { PrivateName, Value, type PropertyKeyValue } from '../value.mts';
+import {
+  Assert,
+  OrdinaryFunctionCreate,
+  SetFunctionName,
+  MakeConstructor,
+  sourceTextMatchedBy,
+} from '../abstract-ops/all.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { DeclarativeEnvironmentRecord } from '../environment.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiateordinaryfunctionexpression */
+//   FunctionExpression :
+//     `function` `(` FormalParameters `)` `{` FunctionBody `}`
+//     `function` BindingIdentifier `(` FormalParameters `)` `{` FunctionBody `}`
+export function InstantiateOrdinaryFunctionExpression(FunctionExpression: ParseNode.FunctionExpression, name?: PropertyKeyValue | PrivateName) {
+  const { BindingIdentifier, FormalParameters, FunctionBody } = FunctionExpression;
+  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 sourceText be the source text matched by FunctionExpression.
+    const sourceText = sourceTextMatchedBy(FunctionExpression);
+    // 8. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, FormalParameters, FunctionBody, non-lexical-this, funcEnv, privateScope).
+    const closure = OrdinaryFunctionCreate(surroundingAgent.intrinsic('%Function.prototype%'), sourceText, FormalParameters, FunctionBody, 'non-lexical-this', funcEnv, privateScope);
+    // 9. Perform SetFunctionName(closure, name).
+    SetFunctionName(closure, name);
+    // 10. Perform MakeConstructor(closure).
+    MakeConstructor(closure);
+    // 11. Perform funcEnv.InitializeBinding(name, closure).
+    funcEnv.InitializeBinding(name, closure);
+    // 12. Return closure.
+    return closure;
+  }
+  // 1. If name is not present, set name to "".
+  if (name === undefined) {
+    name = Value('');
+  }
+  // 2. Let scope be the running execution context's LexicalEnvironment.
+  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 FunctionExpression.
+  const sourceText = sourceTextMatchedBy(FunctionExpression);
+  // 5. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, FormalParameters, FunctionBody, non-lexical-this, scope, privateScope).
+  const closure = OrdinaryFunctionCreate(surroundingAgent.intrinsic('%Function.prototype%'), sourceText, FormalParameters, FunctionBody, 'non-lexical-this', scope, privateScope);
+  // 6. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 7. Perform MakeConstructor(closure).
+  MakeConstructor(closure);
+  // 8. Return closure.
+  return closure;
+}