The Link concrete method of a Cyclic Module Record module takes no arguments and returns either a normal completion containing unused or an abrupt completion. On success, Link transitions this module's [[Status]] from unlinked to linked. On failure, an exception is thrown and this module's [[Status]] remains unlinked. (Most of the work is done by the auxiliary function InnerModuleLinking.) It performs the following steps when called:

1. Assert: module.[[Status]] is not linking or evaluating.
2. Let stack be a new empty List.
3. Let result be Completion(InnerModuleLinking(module, stack, 0)).
4. If result is an abrupt completion, then
   1. For each Cyclic Module Record m of stack, do
      1. Assert: m.[[Status]] is linking.
      2. Set m.[[Status]] to unlinked.
   2. Assert: module.[[Status]] is unlinked.
   3. Return ? result.
5. Assert: module.[[Status]] is linked, evaluating-async, or evaluated.
6. Assert: stack is empty.
7. Return unused.

The Evaluate concrete method of a Cyclic Module Record module takes no arguments and returns a Promise. Evaluate transitions this module's [[Status]] from linked to either evaluating-async or evaluated. The first time it is called on a module in a given strongly connected component, Evaluate creates and returns a Promise which resolves when the module has finished evaluating. This Promise is stored in the [[TopLevelCapability]] field of the [[CycleRoot]] for the component. Future invocations of Evaluate on any module in the component return the same Promise. (Most of the work is done by the auxiliary function InnerModuleEvaluation.) It performs the following steps when called:

1. Assert: This call to Evaluate is not happening at the same time as another call to Evaluate within the surrounding agent.
2. Assert: module.[[Status]] is linked, evaluating-async, or evaluated.
3. If module.[[Status]] is evaluating-async or evaluated, set module to module.[[CycleRoot]].
4. If module.[[TopLevelCapability]] is not empty, then
   1. Return module.[[TopLevelCapability]].[[Promise]].
5. Let stack be a new empty List.
6. Let capability be ! NewPromiseCapability(%Promise%).
7. Set module.[[TopLevelCapability]] to capability.
8. Let result be Completion(InnerModuleEvaluation(module, stack, 0)).
9. If result is an abrupt completion, then
   1. For each Cyclic Module Record m of stack, do
      1. Assert: m.[[Status]] is evaluating.
      2. Set m.[[Status]] to evaluated.
      3. Set m.[[EvaluationError]] to result.
   2. Assert: module.[[Status]] is evaluated.
   3. Assert: module.[[EvaluationError]] is result.
   4. Perform ! Call(capability.[[Reject]], undefined, « result.[[Value]] »).
10. Else,
    1. Assert: module.[[Status]] is evaluating-async or evaluated.
    2. Assert: module.[[EvaluationError]] is empty.
    3. If module.[[AsyncEvaluation]] is false, then
       1. Assert: module.[[Status]] is evaluated.
       2. Perform ! Call(capability.[[Resolve]], undefined, « undefined »).
    4. Assert: stack is empty.
11. Return capability.[[Promise]].

This non-normative section gives a series of examples of the linking and evaluation of a few common module graphs, with a specific focus on how errors can occur.

First consider the following simple module graph:

Let's first assume that there are no error conditions. When a host first calls A.Link(), this will complete successfully by assumption, and recursively link modules B and C as well, such that A.[[Status]] = B.[[Status]] = C.[[Status]] = linked. This preparatory step can be performed at any time. Later, when the host is ready to incur any possible side effects of the modules, it can call A.Evaluate(), which will complete successfully, returning a Promise resolving to undefined (again by assumption), recursively having evaluated first C and then B. Each module's [[Status]] at this point will be evaluated.

Consider then cases involving linking errors. If InnerModuleLinking of C succeeds but, thereafter, fails for B, for example because it imports something that C does not provide, then the original A.Link() will fail, and both A and B's [[Status]] remain unlinked. C's [[Status]] has become linked, though.

Finally, consider a case involving evaluation errors. If InnerModuleEvaluation of C succeeds but, thereafter, fails for B, for example because B contains code that throws an exception, then the original A.Evaluate() will fail, returning a rejected Promise. The resulting exception will be recorded in both A and B's [[EvaluationError]] fields, and their [[Status]] will become evaluated. C will also become evaluated but, in contrast to A and B, will remain without an [[EvaluationError]], as it successfully completed evaluation. Storing the exception ensures that any time a host tries to reuse A or B by calling their Evaluate() method, it will encounter the same exception. (Hosts are not required to reuse Cyclic Module Records; similarly, hosts are not required to expose the exception objects thrown by these methods. However, the specification enables such uses.)

The difference here between linking and evaluation errors is due to how evaluation must be only performed once, as it can cause side effects; it is thus important to remember whether evaluation has already been performed, even if unsuccessfully. (In the error case, it makes sense to also remember the exception because otherwise subsequent Evaluate() calls would have to synthesize a new one.) Linking, on the other hand, is side-effect-free, and thus even if it fails, it can be retried at a later time with no issues.

Now consider a different type of error condition:

In this scenario, module A declares a dependency on some other module, but no Module Record exists for that module, i.e. HostResolveImportedModule throws an exception when asked for it. This could occur for a variety of reasons, such as the corresponding resource not existing, or the resource existing but ParseModule throwing an exception when trying to parse the resulting source text. Hosts can choose to expose the cause of failure via the exception they throw from HostResolveImportedModule. In any case, this exception causes a linking failure, which as before results in A's [[Status]] remaining unlinked.

Now, consider a module graph with a cycle:

Here we assume that the entry point is module A, so that the host proceeds by calling A.Link(), which performs InnerModuleLinking on A. This in turn calls InnerModuleLinking on B. Because of the cycle, this again triggers InnerModuleLinking on A, but at this point it is a no-op since A.[[Status]] is already linking. B.[[Status]] itself remains linking when control gets back to A and InnerModuleLinking is triggered on C. After this returns with C.[[Status]] being linked, both A and B transition from linking to linked together; this is by design, since they form a strongly connected component.

An analogous story occurs for the evaluation phase of a cyclic module graph, in the success case.

Now consider a case where A has an linking error; for example, it tries to import a binding from C that does not exist. In that case, the above steps still occur, including the early return from the second call to InnerModuleLinking on A. However, once we unwind back to the original InnerModuleLinking on A, it fails during InitializeEnvironment, namely right after C.ResolveExport(). The thrown SyntaxError exception propagates up to A.Link, which resets all modules that are currently on its stack (these are always exactly the modules that are still linking). Hence both A and B become unlinked. Note that C is left as linked.

Alternatively, consider a case where A has an evaluation error; for example, its source code throws an exception. In that case, the evaluation-time analog of the above steps still occurs, including the early return from the second call to InnerModuleEvaluation on A. However, once we unwind back to the original InnerModuleEvaluation on A, it fails by assumption. The exception thrown propagates up to A.Evaluate(), which records the error in all modules that are currently on its stack (i.e., the modules that are still evaluating) as well as via [[AsyncParentModules]], which form a chain for modules which contain or depend on top-level await through the whole dependency graph through the AsyncModuleExecutionRejected algorithm. Hence both A and B become evaluated and the exception is recorded in both A and B's [[EvaluationError]] fields, while C is left as evaluated with no [[EvaluationError]].

Lastly, consider a module graph with a cycle, where all modules complete asynchronously:

Linking happens as before, and all modules end up with [[Status]] set to linked.

Calling A.Evaluate() calls InnerModuleEvaluation on A, B, and D, which all transition to evaluating. Then InnerModuleEvaluation is called on A again, which is a no-op because it is already evaluating. At this point, D.[[PendingAsyncDependencies]] is 0, so ExecuteAsyncModule(D) is called and we call D.ExecuteModule with a new PromiseCapability tracking the asynchronous execution of D. We unwind back to the InnerModuleEvaluation on B, setting B.[[PendingAsyncDependencies]] to 1 and B.[[AsyncEvaluation]] to true. We unwind back to the original InnerModuleEvaluation on A, setting A.[[PendingAsyncDependencies]] to 1. In the next iteration of the loop over A's dependencies, we call InnerModuleEvaluation on C and thus on D (again a no-op) and E. As E has no dependencies and is not part of a cycle, we call ExecuteAsyncModule(E) in the same manner as D and E is immediately removed from the stack. We unwind once more to the original InnerModuleEvaluation on A, setting C.[[AsyncEvaluation]] to true. Now we finish the loop over A's dependencies, set A.[[AsyncEvaluation]] to true, and remove the entire strongly connected component from the stack, transitioning all of the modules to evaluating-async at once. At this point, the fields of the modules are as given in Table 48.

Module	[[DFSIndex]]	[[DFSAncestorIndex]]	[[Status]]	[[AsyncEvaluation]]	[[AsyncParentModules]]	[[PendingAsyncDependencies]]
A	0	0	evaluating-async	true	« »	2 (B and C)
B	1	0	evaluating-async	true	« A »	1 (D)
C	2	0	evaluating-async	true	« A »	2 (D and E)
D	3	0	evaluating-async	true	« B, C »	0
E	4	4	evaluating-async	true	« C »	0

Let us assume that E finishes executing first. When that happens, AsyncModuleExecutionFulfilled is called, E.[[Status]] is set to evaluated and C.[[PendingAsyncDependencies]] is decremented to become 1. The fields of the updated modules are as given in Table 49.

Module	[[DFSIndex]]	[[DFSAncestorIndex]]	[[Status]]	[[AsyncEvaluation]]	[[AsyncParentModules]]	[[PendingAsyncDependencies]]
C	2	0	evaluating-async	true	« A »	1 (D)
E	4	4	evaluated	true	« C »	0

D is next to finish (as it was the only module that was still executing). When that happens, AsyncModuleExecutionFulfilled is called again and D.[[Status]] is set to evaluated. Then B.[[PendingAsyncDependencies]] is decremented to become 0, ExecuteAsyncModule is called on B, and it starts executing. C.[[PendingAsyncDependencies]] is also decremented to become 0, and C starts executing (potentially in parallel to B if B contains an await). The fields of the updated modules are as given in Table 50.

Module	[[DFSIndex]]	[[DFSAncestorIndex]]	[[Status]]	[[AsyncEvaluation]]	[[AsyncParentModules]]	[[PendingAsyncDependencies]]
B	1	0	evaluating-async	true	« A »	0
C	2	0	evaluating-async	true	« A »	0
D	3	0	evaluated	true	« B, C »	0

Let us assume that C finishes executing next. When that happens, AsyncModuleExecutionFulfilled is called again, C.[[Status]] is set to evaluated and A.[[PendingAsyncDependencies]] is decremented to become 1. The fields of the updated modules are as given in Table 51.

Module	[[DFSIndex]]	[[DFSAncestorIndex]]	[[Status]]	[[AsyncEvaluation]]	[[AsyncParentModules]]	[[PendingAsyncDependencies]]
A	0	0	evaluating-async	true	« »	1 (B)
C	2	0	evaluated	true	« A »	0

Then, B finishes executing. When that happens, AsyncModuleExecutionFulfilled is called again and B.[[Status]] is set to evaluated. A.[[PendingAsyncDependencies]] is decremented to become 0, so ExecuteAsyncModule is called and it starts executing. The fields of the updated modules are as given in Table 52.

Module	[[DFSIndex]]	[[DFSAncestorIndex]]	[[Status]]	[[AsyncEvaluation]]	[[AsyncParentModules]]	[[PendingAsyncDependencies]]
A	0	0	evaluating-async	true	« »	0
B	1	0	evaluated	true	« A »	0

Finally, A finishes executing. When that happens, AsyncModuleExecutionFulfilled is called again and A.[[Status]] is set to evaluated. At this point, the Promise in A.[[TopLevelCapability]] (which was returned from A.Evaluate()) is resolved, and this concludes the handling of this module graph. The fields of the updated module are as given in Table 53.

Module	[[DFSIndex]]	[[DFSAncestorIndex]]	[[Status]]	[[AsyncEvaluation]]	[[AsyncParentModules]]	[[PendingAsyncDependencies]]
A	0	0	evaluated	true	« »	0

Alternatively, consider a failure case where C fails execution and returns an error before B has finished executing. When that happens, AsyncModuleExecutionRejected is called, which sets C.[[Status]] to evaluated and C.[[EvaluationError]] to the error. It then propagates this error to all of the AsyncParentModules by performing AsyncModuleExecutionRejected on each of them. The fields of the updated modules are as given in Table 54.

Module	[[DFSIndex]]	[[DFSAncestorIndex]]	[[Status]]	[[AsyncEvaluation]]	[[AsyncParentModules]]	[[PendingAsyncDependencies]]	[[EvaluationError]]
A	0	0	evaluated	true	« »	1 (B)	empty
C	2	1	evaluated	true	« A »	0	C's evaluation error

A will be rejected with the same error as C since C will call AsyncModuleExecutionRejected on A with C's error. A.[[Status]] is set to evaluated. At this point the Promise in A.[[TopLevelCapability]] (which was returned from A.Evaluate()) is rejected. The fields of the updated module are as given in Table 55.

Module	[[DFSIndex]]	[[DFSAncestorIndex]]	[[Status]]	[[AsyncEvaluation]]	[[AsyncParentModules]]	[[PendingAsyncDependencies]]	[[EvaluationError]]
A	0	0	evaluated	true	« »	0	C's Evaluation Error

Then, B finishes executing without an error. When that happens, AsyncModuleExecutionFulfilled is called again and B.[[Status]] is set to evaluated. GatherAvailableAncestors is called on B. However, A.[[CycleRoot]] is A which has an evaluation error, so it will not be added to the returned sortedExecList and AsyncModuleExecutionFulfilled will return without further processing. Any future importer of B will resolve the rejection of B.[[CycleRoot]].[[EvaluationError]] from the evaluation error from C that was set on the cycle root A. The fields of the updated modules are as given in Table 56.

Module	[[DFSIndex]]	[[DFSAncestorIndex]]	[[Status]]	[[AsyncEvaluation]]	[[AsyncParentModules]]	[[PendingAsyncDependencies]]	[[EvaluationError]]
A	0	0	evaluated	true	« »	0	C's Evaluation Error
B	1	0	evaluated	true	« A »	0	empty

The abstract operation ParseModule takes arguments sourceText (ECMAScript source text), realm, and hostDefined and returns a Source Text Module Record or a non-empty List of SyntaxError objects. It creates a Source Text Module Record based upon the result of parsing sourceText as a Module. It performs the following steps when called:

1. Let body be ParseText(sourceText, Module).
2. If body is a List of errors, return body.
3. Let requestedModules be the ModuleRequests of body.
4. Let importEntries be ImportEntries of body.
5. Let importedBoundNames be ImportedLocalNames(importEntries).
6. Let indirectExportEntries be a new empty List.
7. Let localExportEntries be a new empty List.
8. Let starExportEntries be a new empty List.
9. Let exportEntries be ExportEntries of body.
10. For each ExportEntry Record ee of exportEntries, do
    1. If ee.[[ModuleRequest]] is null, then
       1. If ee.[[LocalName]] is not an element of importedBoundNames, then
          1. Append ee to localExportEntries.
       2. Else,
          1. Let ie be the element of importEntries whose [[LocalName]] is the same as ee.[[LocalName]].
          2. If ie.[[ImportName]] is namespace-object, then
             1. NOTE: This is a re-export of an imported module namespace object.
             2. Append ee to localExportEntries.
          3. Else,
             1. NOTE: This is a re-export of a single name.
             2. Append the ExportEntry Record { [[ModuleRequest]]: ie.[[ModuleRequest]], [[ImportName]]: ie.[[ImportName]], [[LocalName]]: null, [[ExportName]]: ee.[[ExportName]] } to indirectExportEntries.
    2. Else if ee.[[ImportName]] is all-but-default, then
       1. Assert: ee.[[ExportName]] is null.
       2. Append ee to starExportEntries.
    3. Else,
       1. Append ee to indirectExportEntries.
11. Let async be body Contains await.
12. Return Source Text Module Record { [[Realm]]: realm, [[Environment]]: empty, [[Namespace]]: empty, [[CycleRoot]]: empty, [[HasTLA]]: async, [[AsyncEvaluation]]: false, [[TopLevelCapability]]: empty, [[AsyncParentModules]]: « », [[PendingAsyncDependencies]]: empty, [[Status]]: unlinked, [[EvaluationError]]: empty, [[HostDefined]]: hostDefined, [[ECMAScriptCode]]: body, [[Context]]: empty, [[ImportMeta]]: empty, [[RequestedModules]]: requestedModules, [[ImportEntries]]: importEntries, [[LocalExportEntries]]: localExportEntries, [[IndirectExportEntries]]: indirectExportEntries, [[StarExportEntries]]: starExportEntries, [[DFSIndex]]: empty, [[DFSAncestorIndex]]: empty }.

Note

An implementation may parse module source text and analyse it for Early Error conditions prior to the evaluation of ParseModule for that module source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseModule upon that source text.

The GetExportedNames concrete method of a Source Text Module Record module takes optional argument exportStarSet (a List of Source Text Module Records) and returns either a normal completion containing a List of either Strings or null, or an abrupt completion. It performs the following steps when called:

1. If exportStarSet is not present, set exportStarSet to a new empty List.
2. If exportStarSet contains module, then
   1. Assert: We've reached the starting point of an export * circularity.
   2. Return a new empty List.
3. Append module to exportStarSet.
4. Let exportedNames be a new empty List.
5. For each ExportEntry Record e of module.[[LocalExportEntries]], do
   1. Assert: module provides the direct binding for this export.
   2. Append e.[[ExportName]] to exportedNames.
6. For each ExportEntry Record e of module.[[IndirectExportEntries]], do
   1. Assert: module imports a specific binding for this export.
   2. Append e.[[ExportName]] to exportedNames.
7. For each ExportEntry Record e of module.[[StarExportEntries]], do
   1. Let requestedModule be ? HostResolveImportedModule(module, e.[[ModuleRequest]]).
   2. Let starNames be ? requestedModule.GetExportedNames(exportStarSet).
   3. For each element n of starNames, do
      1. If SameValue(n, "default") is false, then
         1. If n is not an element of exportedNames, then
            1. Append n to exportedNames.
8. Return exportedNames.

Note

GetExportedNames does not filter out or throw an exception for names that have ambiguous star export bindings.

The ResolveExport concrete method of a Source Text Module Record module takes argument exportName (a String) and optional argument resolveSet (a List of Records that have [[Module]] and [[ExportName]] fields) and returns either a normal completion containing either a ResolvedBinding Record, null, or ambiguous, or an abrupt completion.

ResolveExport attempts to resolve an imported binding to the actual defining module and local binding name. The defining module may be the module represented by the Module Record this method was invoked on or some other module that is imported by that module. The parameter resolveSet is used to detect unresolved circular import/export paths. If a pair consisting of specific Module Record and exportName is reached that is already in resolveSet, an import circularity has been encountered. Before recursively calling ResolveExport, a pair consisting of module and exportName is added to resolveSet.

If a defining module is found, a ResolvedBinding Record { [[Module]], [[BindingName]] } is returned. This record identifies the resolved binding of the originally requested export, unless this is the export of a namespace with no local binding. In this case, [[BindingName]] will be set to namespace. If no definition was found or the request is found to be circular, null is returned. If the request is found to be ambiguous, ambiguous is returned.

It performs the following steps when called:

1. If resolveSet is not present, set resolveSet to a new empty List.
2. For each Record { [[Module]], [[ExportName]] } r of resolveSet, do
   1. If module and r.[[Module]] are the same Module Record and SameValue(exportName, r.[[ExportName]]) is true, then
      1. Assert: This is a circular import request.
      2. Return null.
3. Append the Record { [[Module]]: module, [[ExportName]]: exportName } to resolveSet.
4. For each ExportEntry Record e of module.[[LocalExportEntries]], do
   1. If SameValue(exportName, e.[[ExportName]]) is true, then
      1. Assert: module provides the direct binding for this export.
      2. Return ResolvedBinding Record { [[Module]]: module, [[BindingName]]: e.[[LocalName]] }.
5. For each ExportEntry Record e of module.[[IndirectExportEntries]], do
   1. If SameValue(exportName, e.[[ExportName]]) is true, then
      1. Let importedModule be ? HostResolveImportedModule(module, e.[[ModuleRequest]]).
      2. If e.[[ImportName]] is all, then
         1. Assert: module does not provide the direct binding for this export.
         2. Return ResolvedBinding Record { [[Module]]: importedModule, [[BindingName]]: namespace }.
      3. Else,
         1. Assert: module imports a specific binding for this export.
         2. Return ? importedModule.ResolveExport(e.[[ImportName]], resolveSet).
6. If SameValue(exportName, "default") is true, then
   1. Assert: A default export was not explicitly defined by this module.
   2. Return null.
   3. NOTE: A default export cannot be provided by an export * from "mod" declaration.
7. Let starResolution be null.
8. For each ExportEntry Record e of module.[[StarExportEntries]], do
   1. Let importedModule be ? HostResolveImportedModule(module, e.[[ModuleRequest]]).
   2. Let resolution be ? importedModule.ResolveExport(exportName, resolveSet).
   3. If resolution is ambiguous, return ambiguous.
   4. If resolution is not null, then
      1. Assert: resolution is a ResolvedBinding Record.
      2. If starResolution is null, set starResolution to resolution.
      3. Else,
         1. Assert: There is more than one * import that includes the requested name.
         2. If resolution.[[Module]] and starResolution.[[Module]] are not the same Module Record, return ambiguous.
         3. If resolution.[[BindingName]] is namespace and starResolution.[[BindingName]] is not namespace, or if resolution.[[BindingName]] is not namespace and starResolution.[[BindingName]] is namespace, return ambiguous.
         4. If resolution.[[BindingName]] is a String, starResolution.[[BindingName]] is a String, and SameValue(resolution.[[BindingName]], starResolution.[[BindingName]]) is false, return ambiguous.
9. Return starResolution.

The InitializeEnvironment concrete method of a Source Text Module Record module takes no arguments and returns either a normal completion containing unused or an abrupt completion. It performs the following steps when called:

1. For each ExportEntry Record e of module.[[IndirectExportEntries]], do
   1. Let resolution be ? module.ResolveExport(e.[[ExportName]]).
   2. If resolution is null or ambiguous, throw a SyntaxError exception.
   3. Assert: resolution is a ResolvedBinding Record.
2. Assert: All named exports from module are resolvable.
3. Let realm be module.[[Realm]].
4. Assert: realm is not undefined.
5. Let env be NewModuleEnvironment(realm.[[GlobalEnv]]).
6. Set module.[[Environment]] to env.
7. For each ImportEntry Record in of module.[[ImportEntries]], do
   1. Let importedModule be ! HostResolveImportedModule(module, in.[[ModuleRequest]]).
   2. NOTE: The above call cannot fail because imported module requests are a subset of module.[[RequestedModules]], and these have been resolved earlier in this algorithm.
   3. If in.[[ImportName]] is namespace-object, then
      1. Let namespace be ? GetModuleNamespace(importedModule).
      2. Perform ! env.CreateImmutableBinding(in.[[LocalName]], true).
      3. Perform ! env.InitializeBinding(in.[[LocalName]], namespace).
   4. Else,
      1. Let resolution be ? importedModule.ResolveExport(in.[[ImportName]]).
      2. If resolution is null or ambiguous, throw a SyntaxError exception.
      3. If resolution.[[BindingName]] is namespace, then
         1. Let namespace be ? GetModuleNamespace(resolution.[[Module]]).
         2. Perform ! env.CreateImmutableBinding(in.[[LocalName]], true).
         3. Perform ! env.InitializeBinding(in.[[LocalName]], namespace).
      4. Else,
         1. Perform env.CreateImportBinding(in.[[LocalName]], resolution.[[Module]], resolution.[[BindingName]]).
8. Let moduleContext be a new ECMAScript code execution context.
9. Set the Function of moduleContext to null.
10. Assert: module.[[Realm]] is not undefined.
11. Set the Realm of moduleContext to module.[[Realm]].
12. Set the ScriptOrModule of moduleContext to module.
13. Set the VariableEnvironment of moduleContext to module.[[Environment]].
14. Set the LexicalEnvironment of moduleContext to module.[[Environment]].
15. Set the PrivateEnvironment of moduleContext to null.
16. Set module.[[Context]] to moduleContext.
17. Push moduleContext onto the execution context stack; moduleContext is now the running execution context.
18. Let code be module.[[ECMAScriptCode]].
19. Let varDeclarations be the VarScopedDeclarations of code.
20. Let declaredVarNames be a new empty List.
21. For each element d of varDeclarations, do
    1. For each element dn of the BoundNames of d, do
       1. If dn is not an element of declaredVarNames, then
          1. Perform ! env.CreateMutableBinding(dn, false).
          2. Perform ! env.InitializeBinding(dn, undefined).
          3. Append dn to declaredVarNames.
22. Let lexDeclarations be the LexicallyScopedDeclarations of code.
23. Let privateEnv be null.
24. For each element d of lexDeclarations, do
    1. For each element dn of the BoundNames of d, do
       1. If IsConstantDeclaration of d is true, then
          1. Perform ! env.CreateImmutableBinding(dn, true).
       2. Else,
          1. Perform ! env.CreateMutableBinding(dn, false).
       3. If d is a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration, then
          1. Let fo be InstantiateFunctionObject of d with arguments env and privateEnv.
          2. Perform ! env.InitializeBinding(dn, fo).
25. Remove moduleContext from the execution context stack.
26. Return unused.

The ExecuteModule concrete method of a Source Text Module Record module takes optional argument capability and returns either a normal completion containing unused or an abrupt completion. It performs the following steps when called:

1. Let moduleContext be a new ECMAScript code execution context.
2. Set the Function of moduleContext to null.
3. Set the Realm of moduleContext to module.[[Realm]].
4. Set the ScriptOrModule of moduleContext to module.
5. Assert: module has been linked and declarations in its module environment have been instantiated.
6. Set the VariableEnvironment of moduleContext to module.[[Environment]].
7. Set the LexicalEnvironment of moduleContext to module.[[Environment]].
8. Suspend the currently running execution context.
9. If module.[[HasTLA]] is false, then
   1. Assert: capability is not present.
   2. Push moduleContext onto the execution context stack; moduleContext is now the running execution context.
   3. Let result be the result of evaluating module.[[ECMAScriptCode]].
   4. Suspend moduleContext and remove it from the execution context stack.
   5. Resume the context that is now on the top of the execution context stack as the running execution context.
   6. If result is an abrupt completion, then
      1. Return ? result.
10. Else,
    1. Assert: capability is a PromiseCapability Record.
    2. Perform AsyncBlockStart(capability, module.[[ECMAScriptCode]], moduleContext).
11. Return unused.