Movatterモバイル変換

opt

StatementList

[~Yield, ~Await, ~Return]

16.1.1 Static Semantics: Early Errors

It is a Syntax Error if theLexicallyDeclaredNames ofScriptBody contains any duplicate entries.
It is a Syntax Error if any element of theLexicallyDeclaredNames ofScriptBody also occurs in theVarDeclaredNames ofScriptBody.

StatementList

It is a Syntax Error ifStatementListContainssuper unless the source text containingsuper is eval code that is being processed by adirect eval. Additionalearly error rules forsuper withindirect eval are defined in19.2.1.1.
It is a Syntax Error ifStatementListContainsNewTarget unless the source text containingNewTarget is eval code that is being processed by adirect eval. Additionalearly error rules forNewTarget indirect eval are defined in19.2.1.1.
It is a Syntax Error ifContainsDuplicateLabels ofStatementList with argument « » istrue.
It is a Syntax Error ifContainsUndefinedBreakTarget ofStatementList with argument « » istrue.
It is a Syntax Error ifContainsUndefinedContinueTarget ofStatementList with arguments « » and « » istrue.
It is a Syntax Error ifAllPrivateIdentifiersValid ofStatementList with argument « » isfalse unless the source text containingScriptBody is eval code that is being processed by adirect eval.

16.1.2 Static Semantics: ScriptIsStrict

Thesyntax-directed operation ScriptIsStrict takes no arguments and returns a Boolean. It is defined piecewise over the following productions:

opt

IfScriptBody is present and theDirective Prologue ofScriptBody contains aUse Strict Directive, returntrue; otherwise returnfalse.

16.1.3 Runtime Semantics: Evaluation

[empty]

Returnundefined.

16.1.4 Script Records

AScript Record encapsulates information about a script being evaluated. Each script record contains the fields listed inTable 37.

Table 37:Script Record Fields

Field Name	Value Type	Meaning
`[[Realm]]`	aRealm Record	Therealm within which this script was created.
`[[ECMAScriptCode]]`	aScriptParse Node	The result of parsing the source text of this script.
`[[LoadedModules]]`	aList ofLoadedModuleRequest Records	A map from the specifier strings imported by this script to the resolvedModule Record. The list does not contain two differentRecords`r1` and`r2` such thatModuleRequestsEqual(`r1`,`r2`) istrue.
`[[HostDefined]]`	anything (default value isempty)	Field reserved for use byhost environments that need to associate additional information with a script.

16.1.5 ParseScript (`sourceText`,`realm`,`hostDefined` )

The abstract operation ParseScript takes argumentssourceText (ECMAScript source text),realm (aRealm Record), andhostDefined (anything) and returns aScript Record or a non-emptyList ofSyntaxError objects. It creates aScript Record based upon the result of parsingsourceText as aScript. It performs the following steps when called:

Letscript beParseText(sourceText,Script).
Ifscript is aList of errors, returnscript.
ReturnScript Record {[[Realm]]:realm,[[ECMAScriptCode]]:script,[[LoadedModules]]: « »,[[HostDefined]]:hostDefined }.

Note

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

16.1.6 ScriptEvaluation (`scriptRecord` )

The abstract operation ScriptEvaluation takes argumentscriptRecord (aScript Record) and returns either anormal completion containing anECMAScript language value or anabrupt completion. It performs the following steps when called:

LetglobalEnv bescriptRecord.[[Realm]].[[GlobalEnv]].
LetscriptContext be a newECMAScript code execution context.
Set the Function ofscriptContext tonull.
Set theRealm ofscriptContext toscriptRecord.[[Realm]].
Set the ScriptOrModule ofscriptContext toscriptRecord.
Set the VariableEnvironment ofscriptContext toglobalEnv.
Set the LexicalEnvironment ofscriptContext toglobalEnv.
Set the PrivateEnvironment ofscriptContext tonull.
Suspend therunning execution context.
PushscriptContext onto theexecution context stack;scriptContext is now therunning execution context.
Letscript bescriptRecord.[[ECMAScriptCode]].
Letresult beCompletion(GlobalDeclarationInstantiation(script,globalEnv)).
Ifresult is anormal completion, then
1. Setresult toCompletion(Evaluation ofscript).
2. Ifresult is anormal completion andresult.[[Value]] isempty, then
  1. Setresult toNormalCompletion(undefined).
SuspendscriptContext and remove it from theexecution context stack.
Assert: Theexecution context stack is not empty.
Resume the context that is now on the top of theexecution context stack as therunning execution context.
Return ? result.

16.1.7 GlobalDeclarationInstantiation (`script`,`env` )

The abstract operation GlobalDeclarationInstantiation takes argumentsscript (aScriptParse Node) andenv (aGlobal Environment Record) and returns either anormal completion containingunused or athrow completion.script is theScript for which theexecution context is being established.env is the global environment in which bindings are to be created.

Note 1

When anexecution context is established for evaluating scripts, declarations are instantiated in the current global environment. Each global binding declared in the code is instantiated.

It performs the following steps when called:

LetlexNames be theLexicallyDeclaredNames ofscript.
LetvarNames be theVarDeclaredNames ofscript.
For each elementname oflexNames, do
1. IfHasLexicalDeclaration(env,name) istrue, throw aSyntaxError exception.
2. LethasRestrictedGlobal be ? HasRestrictedGlobalProperty(env,name).
3. NOTE: Globalvar andfunction bindings (except those that are introduced by non-strictdirect eval) are non-configurable and are therefore restricted global properties.
4. IfhasRestrictedGlobal istrue, throw aSyntaxError exception.
For each elementname ofvarNames, do
1. IfHasLexicalDeclaration(env,name) istrue, throw aSyntaxError exception.
LetvarDeclarations be theVarScopedDeclarations ofscript.
LetfunctionsToInitialize be a new emptyList.
LetdeclaredFunctionNames be a new emptyList.
For each elementd ofvarDeclarations, in reverseList order, do
1. Ifd is not either aVariableDeclaration, aForBinding, or aBindingIdentifier, then
  1. Assert:d is either aFunctionDeclaration, aGeneratorDeclaration, anAsyncFunctionDeclaration, or anAsyncGeneratorDeclaration.
  2. NOTE: If there are multiple function declarations for the same name, the last declaration is used.
  3. Letfn be the sole element of theBoundNames ofd.
  4. IfdeclaredFunctionNames does not containfn, then
    1. LetfnDefinable be ? CanDeclareGlobalFunction(env,fn).
    2. IffnDefinable isfalse, throw aTypeError exception.
    3. Appendfn todeclaredFunctionNames.
    4. Insertd as the first element offunctionsToInitialize.
LetdeclaredVarNames be a new emptyList.
For each elementd ofvarDeclarations, do
1. Ifd is either aVariableDeclaration, aForBinding, or aBindingIdentifier, then
  1. For each Stringvn of theBoundNames ofd, do
    1. IfdeclaredFunctionNames does not containvn, then
      1. LetvnDefinable be ? CanDeclareGlobalVar(env,vn).
      2. IfvnDefinable isfalse, throw aTypeError exception.
      3. IfdeclaredVarNames does not containvn, then
        Appendvn todeclaredVarNames.
NOTE: No abnormal terminations occur after this algorithm step if theglobal object is anordinary object. However, if theglobal object is aProxy exotic object it may exhibit behaviours that cause abnormal terminations in some of the following steps.
Normative Optional
If thehost is a web browser or otherwise supportsBlock-Level Function Declarations Web Legacy Compatibility Semantics, then
1. Letstrict beScriptIsStrict ofscript.
2. Ifstrict isfalse, then
  1. LetdeclaredFunctionOrVarNames be thelist-concatenation ofdeclaredFunctionNames anddeclaredVarNames.
  2. For eachFunctionDeclarationf that is directly contained in theStatementList of anyBlock,CaseClause, orDefaultClausex such thatscriptContainsx istrue, do
    1. LetF be theStringValue of theBindingIdentifier off.
    2. If replacing theFunctionDeclarationf with aVariableStatement that hasF as aBindingIdentifier would not produce any Early Errors forscript, then
      1. IfHasLexicalDeclaration(env,F) isfalse, then
        LetfnDefinable be ? CanDeclareGlobalVar(env,F).
        IffnDefinable istrue, then
        NOTE: A var binding forF is only instantiated here if it is neither a VarDeclaredName nor the name of anotherFunctionDeclaration.
        IfdeclaredFunctionOrVarNames does not containF, then
        Perform ? CreateGlobalVarBinding(env,F,false).
        AppendF todeclaredFunctionOrVarNames.
        When theFunctionDeclarationf is evaluated, perform the following steps in place of theFunctionDeclarationEvaluation algorithm provided in15.2.6:
        LetgEnv be therunning execution context's VariableEnvironment.
        LetbEnv be therunning execution context's LexicalEnvironment.
        LetfObj be ! bEnv.GetBindingValue(F,false).
        Perform ? gEnv.SetMutableBinding(F,fObj,false).
        Returnunused.
LetlexDeclarations be theLexicallyScopedDeclarations ofscript.
LetprivateEnv benull.
For each elementd oflexDeclarations, do
1. NOTE: Lexically declared names are only instantiated here but not initialized.
2. For each elementdn of theBoundNames ofd, do
  1. IfIsConstantDeclaration ofd istrue, then
    1. Perform ? env.CreateImmutableBinding(dn,true).
  2. Else,
    1. Perform ? env.CreateMutableBinding(dn,false).
For eachParse Nodef offunctionsToInitialize, do
1. Letfn be the sole element of theBoundNames off.
2. Letfo beInstantiateFunctionObject off with argumentsenv andprivateEnv.
3. Perform ? CreateGlobalFunctionBinding(env,fn,fo,false).
For each Stringvn ofdeclaredVarNames, do
1. Perform ? CreateGlobalVarBinding(env,vn,false).
Returnunused.

Note 2

Early errors specified in16.1.1 prevent name conflicts between function/var declarations and let/const/class declarations as well as redeclaration of let/const/class bindings for declaration contained within a singleScript. However, such conflicts and redeclarations that span more than oneScript are detected as runtime errors during GlobalDeclarationInstantiation. If any such errors are detected, no bindings are instantiated for the script. However, if theglobal object is defined usingProxy exotic objects then the runtime tests for conflicting declarations may be unreliable resulting in anabrupt completion and some global declarations not being instantiated. If this occurs, the code for theScript is not evaluated.

Unlike explicit var or function declarations, properties that are directly created on theglobal object result in global bindings that may be shadowed by let/const/class declarations.

16.2 Modules

Syntax

opt

[~Yield, +Await, ~Return]

IdentifierName

16.2.1 Module Semantics

16.2.1.1 Static Semantics: Early Errors

ModuleBody

It is a Syntax Error if theLexicallyDeclaredNames ofModuleItemList contains any duplicate entries.
It is a Syntax Error if any element of theLexicallyDeclaredNames ofModuleItemList also occurs in theVarDeclaredNames ofModuleItemList.
It is a Syntax Error if theExportedNames ofModuleItemList contains any duplicate entries.
It is a Syntax Error if any element of theExportedBindings ofModuleItemList does not also occur in either theVarDeclaredNames ofModuleItemList, or theLexicallyDeclaredNames ofModuleItemList.
It is a Syntax Error ifModuleItemListContainssuper.
It is a Syntax Error ifModuleItemListContainsNewTarget.
It is a Syntax Error ifContainsDuplicateLabels ofModuleItemList with argument « » istrue.
It is a Syntax Error ifContainsUndefinedBreakTarget ofModuleItemList with argument « » istrue.
It is a Syntax Error ifContainsUndefinedContinueTarget ofModuleItemList with arguments « » and « » istrue.
It is a Syntax Error ifAllPrivateIdentifiersValid ofModuleItemList with argument « » isfalse.

Note

The duplicateExportedNames rule implies that multipleexport defaultExportDeclaration items within aModuleBody is a Syntax Error. Additional error conditions relating to conflicting or duplicate declarations are checked during module linking prior to evaluation of aModule. If any such errors are detected theModule is not evaluated.

It is a Syntax Error ifIsStringWellFormedUnicode(SV ofStringLiteral) isfalse.

16.2.1.2 Static Semantics: ImportedLocalNames (`importEntries` )

The abstract operation ImportedLocalNames takes argumentimportEntries (aList ofImportEntry Records) and returns aList of Strings. It creates aList of all of the local name bindings defined byimportEntries. It performs the following steps when called:

LetlocalNames be a new emptyList.
For eachImportEntry Recordi ofimportEntries, do
1. Appendi.[[LocalName]] tolocalNames.
ReturnlocalNames.

16.2.1.3 ModuleRequest Records

AModuleRequest Record represents the request to import a module with given import attributes. It consists of the following fields:

Table 38:ModuleRequest Record Fields

Field Name	Value Type	Meaning
`[[Specifier]]`	a String	The module specifier
`[[Attributes]]`	aList ofImportAttribute Records	The import attributes

ALoadedModuleRequest Record represents the request to import a module together with the resultingModule Record. It consists of the same fields defined in tableTable 38, with the addition of[[Module]]:

Table 39:LoadedModuleRequest Record Fields

Field Name	Value Type	Meaning
`[[Specifier]]`	a String	The module specifier
`[[Attributes]]`	aList ofImportAttribute Records	The import attributes
`[[Module]]`	aModule Record	The loaded module corresponding to this module request

AnImportAttribute Record consists of the following fields:

Table 40:ImportAttribute Record Fields

Field Name	Value Type	Meaning
`[[Key]]`	a String	The attribute key
`[[Value]]`	a String	The attribute value

16.2.1.3.1 ModuleRequestsEqual (`left`,`right` )

The abstract operation ModuleRequestsEqual takes argumentsleft (aModuleRequest Record or aLoadedModuleRequest Record) andright (aModuleRequest Record or aLoadedModuleRequest Record) and returns a Boolean. It performs the following steps when called:

Ifleft.[[Specifier]] is notright.[[Specifier]], returnfalse.
LetleftAttrs beleft.[[Attributes]].
LetrightAttrs beright.[[Attributes]].
LetleftAttrsCount be the number of elements inleftAttrs.
LetrightAttrsCount be the number of elements inrightAttrs.
IfleftAttrsCount ≠rightAttrsCount, returnfalse.
For eachImportAttribute Recordl ofleftAttrs, do
1. IfrightAttrs does not contain anImportAttribute Recordr such thatl.[[Key]] isr.[[Key]] andl.[[Value]] isr.[[Value]], returnfalse.
Returntrue.

16.2.1.4 Static Semantics: ModuleRequests

Thesyntax-directed operation ModuleRequests takes no arguments and returns aList ofModuleRequest Records. It is defined piecewise over the following productions:

[empty]

Return a new emptyList.

Return theModuleRequests ofModuleItem.

Letrequests be theModuleRequests ofModuleItemList.
LetadditionalRequests be theModuleRequests ofModuleItem.
For eachModuleRequest Recordmr ofadditionalRequests, do
1. Ifrequests does not contain aModuleRequest Recordmr2 such thatModuleRequestsEqual(mr,mr2) istrue, then
  1. Appendmr torequests.
Returnrequests.

Return a new emptyList.

import

FromClause

;

Letspecifier be theSV ofFromClause.
Return aList whose sole element is theModuleRequest Record {[[Specifier]]:specifier,[[Attributes]]: « » }.

import

;

Letspecifier be theSV ofFromClause.
Letattributes beWithClauseToAttributes ofWithClause.
Return aList whose sole element is theModuleRequest Record {[[Specifier]]:specifier,[[Attributes]]:attributes }.

import

;

Letspecifier be theSV ofModuleSpecifier.
Return aList whose sole element is theModuleRequest Record {[[Specifier]]:specifier,[[Attributes]]: « » }.

import

;

Letspecifier be theSV ofModuleSpecifier.
Letattributes beWithClauseToAttributes ofWithClause.
Return aList whose sole element is theModuleRequest Record {[[Specifier]]:specifier,[[Attributes]]:attributes }.

export

FromClause

;

Letspecifier be theSV ofFromClause.
Return aList whose sole element is theModuleRequest Record {[[Specifier]]:specifier,[[Attributes]]: « » }.

export

;

Letspecifier be theSV ofFromClause.
Letattributes beWithClauseToAttributes ofWithClause.
Return aList whose sole element is theModuleRequest Record {[[Specifier]]:specifier,[[Attributes]]:attributes }.

export

;

export

export

export

default

export

default

export

default

;

Return a new emptyList.

16.2.1.5 Abstract Module Records

AModule Record encapsulates structural information about the imports and exports of a single module. This information is used to link the imports and exports of sets of connected modules. A Module Record includes four fields that are only used when evaluating a module.

For specification purposes Module Record values are values of theRecord specification type and can be thought of as existing in a simple object-oriented hierarchy where Module Record is an abstract class with both abstract and concrete subclasses. This specification defines the abstract subclass namedCyclic Module Record and its concrete subclass namedSource Text Module Record. Other specifications and implementations may define additional Module Record subclasses corresponding to alternative module definition facilities that they defined.

Module Record defines the fields listed inTable 41. All Module Definition subclasses include at least those fields. Module Record also defines the abstract method list inTable 42. All Module definition subclasses must provide concrete implementations of these abstract methods.

Table 41:Module Record Fields

Field Name	Value Type	Meaning
`[[Realm]]`	aRealm Record	TheRealm within which this module was created.
`[[Environment]]`	aModule Environment Record orempty	TheEnvironment Record containing the top level bindings for this module. This field is set when the module is linked.
`[[Namespace]]`	an Object orempty	The Module Namespace Object (28.3) if one has been created for this module.
`[[HostDefined]]`	anything (default value isundefined)	Field reserved for use byhost environments that need to associate additional information with a module.

Table 42: Abstract Methods ofModule Records

Method	Purpose
LoadRequestedModules([`hostDefined`])	Prepares the module for linking by recursively loading all its dependencies, and returns a promise.
GetExportedNames([`exportStarSet`])	Return a list of all names that are either directly or indirectly exported from this module. LoadRequestedModules must have completed successfully prior to invoking this method.
ResolveExport(`exportName` [,`resolveSet`])	Return the binding of a name exported by this module. Bindings are represented by aResolvedBinding Record, of the form {`[[Module]]`:Module Record,`[[BindingName]]`: String \|namespace }. If the export is a Module Namespace Object without a direct binding in any module,`[[BindingName]]` will be set tonamespace. Returnnull if the name cannot be resolved, orambiguous if multiple bindings were found. Each time this operation is called with a specific`exportName`,`resolveSet` pair as arguments it must return the same result. LoadRequestedModules must have completed successfully prior to invoking this method.
Link()	Prepare the module for evaluation by transitively resolving all module dependencies and creating aModule Environment Record. LoadRequestedModules must have completed successfully prior to invoking this method.
Evaluate()	Returns a promise for the evaluation of this module and its dependencies, resolving on successful evaluation or if it has already been evaluated successfully, and rejecting for an evaluation error or if it has already been evaluated unsuccessfully. If the promise is rejected,hosts are expected to handle the promise rejection and rethrow the evaluation error. Link must have completed successfully prior to invoking this method.

16.2.1.5.1 EvaluateModuleSync (`module` )

The abstract operation EvaluateModuleSync takes argumentmodule (aModule Record) and returns either anormal completion containingunused or athrow completion. It synchronously evaluatesmodule, provided that the caller guarantees thatmodule's evaluation will return an already settled promise. It performs the following steps when called:

Assert:module is not aCyclic Module Record.
Letpromise bemodule.Evaluate().
Assert:promise.[[PromiseState]] is eitherfulfilled orrejected.
Ifpromise.[[PromiseState]] isrejected, then
1. Ifpromise.[[PromiseIsHandled]] isfalse, performHostPromiseRejectionTracker(promise,"handle").
2. Setpromise.[[PromiseIsHandled]] totrue.
3. ReturnThrowCompletion(promise.[[PromiseResult]]).
Returnunused.

16.2.1.6 Cyclic Module Records

ACyclic Module Record is used to represent information about a module that can participate in dependency cycles with other modules that are subclasses of theCyclic Module Record type.Module Records that are not subclasses of theCyclic Module Record type must not participate in dependency cycles withSource Text Module Records.

In addition to the fields defined inTable 41Cyclic Module Records have the additional fields listed inTable 43

Table 43: Additional Fields ofCyclic Module Records

Field Name	Value Type	Meaning
`[[Status]]`	new,unlinked,linking,linked,evaluating,evaluating-async, orevaluated	Initiallynew. Transitions tounlinked,linking,linked,evaluating, possiblyevaluating-async,evaluated (in that order) as the module progresses throughout its lifecycle.evaluating-async indicates this module is queued to execute on completion of its asynchronous dependencies or it is a module whose`[[HasTLA]]` field istrue that has been executed and is pending top-level completion.
`[[EvaluationError]]`	athrow completion orempty	Athrow completion representing the exception that occurred during evaluation.undefined if no exception occurred or if`[[Status]]` is notevaluated.
`[[DFSAncestorIndex]]`	aninteger orempty	Auxiliary field used during Link and Evaluate only. If`[[Status]]` is eitherlinking orevaluating, this is either the module's depth-first traversal index or that of an "earlier" module in the same strongly connected component.
`[[RequestedModules]]`	aList ofModuleRequest Records	AList of theModuleRequest Records associated with the imports in this module. TheList is in source text occurrence order of the imports.
`[[LoadedModules]]`	aList ofLoadedModuleRequest Records	A map from the specifier strings used by the module represented by this record to request the importation of a module with the relative import attributes to the resolvedModule Record. The list does not contain two differentRecords`r1` and`r2` such thatModuleRequestsEqual(`r1`,`r2`) istrue.
`[[CycleRoot]]`	aCyclic Module Record orempty	The first visited module of the cycle, the root DFS ancestor of the strongly connected component. For a module not in a cycle, this would be the module itself. Once Evaluate has completed, a module's`[[DFSAncestorIndex]]` is the depth-first traversal index of its`[[CycleRoot]]`.
`[[HasTLA]]`	a Boolean	Whether this module is individually asynchronous (for example, if it's aSource Text Module Record containing a top-level await). Having an asynchronous dependency does not mean this field istrue. This field must not change after the module is parsed.
`[[AsyncEvaluationOrder]]`	unset, aninteger, ordone	This field is initially set tounset, and remainsunset for fully synchronous modules. For modules that are either themselves asynchronous or have an asynchronous dependency, it is set to aninteger that determines the order in which execution of pending modules is queued by16.2.1.6.1.3.4. Once the pending module is executed, the field is set todone.
`[[TopLevelCapability]]`	aPromiseCapability Record orempty	If this module is the`[[CycleRoot]]` of some cycle, and Evaluate() was called on some module in that cycle, this field contains thePromiseCapability Record for that entire evaluation. It is used to settle the Promise object that is returned from the Evaluate() abstract method. This field will beempty for any dependencies of that module, unless a top-level Evaluate() has been initiated for some of those dependencies.
`[[AsyncParentModules]]`	aList ofCyclic Module Records	If this module or a dependency has`[[HasTLA]]`true, and execution is in progress, this tracks the parent importers of this module for the top-level execution job. These parent modules will not start executing before this module has successfully completed execution.
`[[PendingAsyncDependencies]]`	aninteger orempty	If this module has any asynchronous dependencies, this tracks the number of asynchronous dependency modules remaining to execute for this module. A module with asynchronous dependencies will be executed when this field reaches 0 and there are no execution errors.

In addition to the methods defined inTable 42Cyclic Module Records have the additional methods listed inTable 44

Table 44: Additional Abstract Methods ofCyclic Module Records

Method	Purpose
InitializeEnvironment()	Initialize theEnvironment Record of the module, including resolving all imported bindings, and create the module'sexecution context.
ExecuteModule([`promiseCapability`])	Evaluate the module's code within itsexecution context. If this module hastrue in`[[HasTLA]]`, then aPromiseCapability Record is passed as an argument, and the method is expected to resolve or reject the given capability. In this case, the method must not throw an exception, but instead reject thePromiseCapability Record if necessary.

AGraphLoadingState Record is aRecord that contains information about the loading process of a module graph. It's used to continue loading after a call toHostLoadImportedModule. EachGraphLoadingState Record has the fields defined inTable 45:

Table 45:GraphLoadingState Record Fields

Field Name	Value Type	Meaning
`[[PromiseCapability]]`	aPromiseCapability Record	The promise to resolve when the loading process finishes.
`[[IsLoading]]`	a Boolean	It is true if the loading process has not finished yet, neither successfully nor with an error.
`[[PendingModulesCount]]`	a non-negativeinteger	It tracks the number of pendingHostLoadImportedModule calls.
`[[Visited]]`	aList ofCyclic Module Records	It is a list of theCyclic Module Records that have been already loaded by the current loading process, to avoid infinite loops with circular dependencies.
`[[HostDefined]]`	anything (default value isempty)	It containshost-defined data to pass from the LoadRequestedModules caller toHostLoadImportedModule.

16.2.1.6.1 Implementation of Module Record Abstract Methods

The following are the concrete methods forCyclic Module Record that implement the correspondingModule Record abstract methods defined inTable 42.

16.2.1.6.1.1 LoadRequestedModules ( [`hostDefined` ] )

The LoadRequestedModules concrete method of aCyclic Module Recordmodule takes optional argumenthostDefined (anything) and returns a Promise. It populates the[[LoadedModules]] of all theModule Records in the dependency graph ofmodule (most of the work is done by the auxiliary functionInnerModuleLoading). It takes an optionalhostDefined parameter that is passed to theHostLoadImportedModule hook. It performs the following steps when called:

IfhostDefined is not present, lethostDefined beempty.
Letpc be ! NewPromiseCapability(%Promise%).
Letstate be theGraphLoadingState Record {[[IsLoading]]:true,[[PendingModulesCount]]: 1,[[Visited]]: « »,[[PromiseCapability]]:pc,[[HostDefined]]:hostDefined }.
PerformInnerModuleLoading(state,module).
Returnpc.[[Promise]].

Note

ThehostDefined parameter can be used to pass additional information necessary to fetch the imported modules. It is used, for example, by HTML to set the correct fetch destination for<link rel="preload" as="..."> tags.import() expressions never set thehostDefined parameter.

16.2.1.6.1.1.1 InnerModuleLoading (`state`,`module` )

The abstract operation InnerModuleLoading takes argumentsstate (aGraphLoadingState Record) andmodule (aModule Record) and returnsunused. It is used by LoadRequestedModules to recursively perform the actual loading process formodule's dependency graph. It performs the following steps when called:

Assert:state.[[IsLoading]] istrue.
Ifmodule is aCyclic Module Record,module.[[Status]] isnew, andstate.[[Visited]] does not containmodule, then
1. Appendmodule tostate.[[Visited]].
2. LetrequestedModulesCount be the number of elements inmodule.[[RequestedModules]].
3. Setstate.[[PendingModulesCount]] tostate.[[PendingModulesCount]] +requestedModulesCount.
4. For eachModuleRequest Recordrequest ofmodule.[[RequestedModules]], do
  1. IfAllImportAttributesSupported(request.[[Attributes]]) isfalse, then
    1. Leterror beThrowCompletion(a newly createdSyntaxError object).
    2. PerformContinueModuleLoading(state,error).
  2. Else ifmodule.[[LoadedModules]] contains aLoadedModuleRequest Recordrecord such thatModuleRequestsEqual(record,request) istrue, then
    1. PerformInnerModuleLoading(state,record.[[Module]]).
  3. Else,
    1. PerformHostLoadImportedModule(module,request,state.[[HostDefined]],state).
    2. NOTE:HostLoadImportedModule will callFinishLoadingImportedModule, which re-enters the graph loading process throughContinueModuleLoading.
  4. Ifstate.[[IsLoading]] isfalse, returnunused.
Assert:state.[[PendingModulesCount]] ≥ 1.
Setstate.[[PendingModulesCount]] tostate.[[PendingModulesCount]] - 1.
Ifstate.[[PendingModulesCount]] = 0, then
1. Setstate.[[IsLoading]] tofalse.
2. For eachCyclic Module Recordloaded ofstate.[[Visited]], do
  1. Ifloaded.[[Status]] isnew, setloaded.[[Status]] tounlinked.
3. Perform ! Call(state.[[PromiseCapability]].[[Resolve]],undefined, «undefined »).
Returnunused.

16.2.1.6.1.1.2 ContinueModuleLoading (`state`,`moduleCompletion` )

The abstract operation ContinueModuleLoading takes argumentsstate (aGraphLoadingState Record) andmoduleCompletion (either anormal completion containing aModule Record or athrow completion) and returnsunused. It is used to re-enter the loading process after a call toHostLoadImportedModule. It performs the following steps when called:

Ifstate.[[IsLoading]] isfalse, returnunused.
IfmoduleCompletion is anormal completion, then
1. PerformInnerModuleLoading(state,moduleCompletion.[[Value]]).
Else,
1. Setstate.[[IsLoading]] tofalse.
2. Perform ! Call(state.[[PromiseCapability]].[[Reject]],undefined, «moduleCompletion.[[Value]] »).
Returnunused.

16.2.1.6.1.2 Link ( )

The Link concrete method of aCyclic Module Recordmodule takes no arguments and returns either anormal completion containingunused or athrow completion. On success, Link transitions this module's[[Status]] fromunlinked tolinked. On failure, an exception is thrown and this module's[[Status]] remainsunlinked. (Most of the work is done by the auxiliary functionInnerModuleLinking.) It performs the following steps when called:

Assert:module.[[Status]] is one ofunlinked,linked,evaluating-async, orevaluated.
Letstack be a new emptyList.
Letresult beCompletion(InnerModuleLinking(module,stack, 0)).
Ifresult is anabrupt completion, then
1. For eachCyclic Module Recordm ofstack, do
  1. Assert:m.[[Status]] islinking.
  2. Setm.[[Status]] tounlinked.
2. Assert:module.[[Status]] isunlinked.
3. Return ? result.
Assert:module.[[Status]] is one oflinked,evaluating-async, orevaluated.
Assert:stack is empty.
Returnunused.

16.2.1.6.1.2.1 InnerModuleLinking (`module`,`stack`,`index` )

The abstract operation InnerModuleLinking takes argumentsmodule (aModule Record),stack (aList ofCyclic Module Records), andindex (a non-negativeinteger) and returns either anormal completion containing a non-negativeinteger or athrow completion. It is used by Link to perform the actual linking process formodule, as well as recursively on all other modules in the dependency graph. Thestack andindex parameters, as well as a module's[[DFSAncestorIndex]] field, keep track of the depth-first search (DFS) traversal. In particular,[[DFSAncestorIndex]] is used to discover strongly connected components (SCCs), such that all modules in an SCC transition tolinked together. It performs the following steps when called:

Ifmodule is not aCyclic Module Record, then
1. Perform ? module.Link().
2. Returnindex.
Ifmodule.[[Status]] is one oflinking,linked,evaluating-async, orevaluated, then
1. Returnindex.
Assert:module.[[Status]] isunlinked.
Setmodule.[[Status]] tolinking.
LetmoduleIndex beindex.
Setmodule.[[DFSAncestorIndex]] toindex.
Setindex toindex + 1.
Appendmodule tostack.
For eachModuleRequest Recordrequest ofmodule.[[RequestedModules]], do
1. LetrequiredModule beGetImportedModule(module,request).
2. Setindex to ? InnerModuleLinking(requiredModule,stack,index).
3. IfrequiredModule is aCyclic Module Record, then
  1. Assert:requiredModule.[[Status]] is one oflinking,linked,evaluating-async, orevaluated.
  2. Assert:requiredModule.[[Status]] islinking if and only ifstack containsrequiredModule.
  3. IfrequiredModule.[[Status]] islinking, then
    1. Setmodule.[[DFSAncestorIndex]] tomin(module.[[DFSAncestorIndex]],requiredModule.[[DFSAncestorIndex]]).
Perform ? module.InitializeEnvironment().
Assert:module occurs exactly once instack.
Assert:module.[[DFSAncestorIndex]] ≤moduleIndex.
Ifmodule.[[DFSAncestorIndex]] =moduleIndex, then
1. Letdone befalse.
2. Repeat, whiledone isfalse,
  1. LetrequiredModule be the last element ofstack.
  2. Remove the last element ofstack.
  3. Assert:requiredModule is aCyclic Module Record.
  4. SetrequiredModule.[[Status]] tolinked.
  5. IfrequiredModule andmodule are the sameModule Record, setdone totrue.
Returnindex.

16.2.1.6.1.3 Evaluate ( )

The Evaluate concrete method of aCyclic Module Recordmodule takes no arguments and returns a Promise. Evaluate transitions this module's[[Status]] fromlinked to eitherevaluating-async orevaluated. 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 functionInnerModuleEvaluation.) It performs the following steps when called:

Assert: This call to Evaluate is not happening at the same time as another call to Evaluate within thesurrounding agent.
Assert:module.[[Status]] is one oflinked,evaluating-async, orevaluated.
Ifmodule.[[Status]] is eitherevaluating-async orevaluated, setmodule tomodule.[[CycleRoot]].
Ifmodule.[[TopLevelCapability]] is notempty, then
1. Returnmodule.[[TopLevelCapability]].[[Promise]].
Letstack be a new emptyList.
Letcapability be ! NewPromiseCapability(%Promise%).
Setmodule.[[TopLevelCapability]] tocapability.
Letresult beCompletion(InnerModuleEvaluation(module,stack, 0)).
Ifresult is anabrupt completion, then
1. For eachCyclic Module Recordm ofstack, do
  1. Assert:m.[[Status]] isevaluating.
  2. Assert:m.[[AsyncEvaluationOrder]] isunset.
  3. Setm.[[Status]] toevaluated.
  4. Setm.[[EvaluationError]] toresult.
2. Assert:module.[[Status]] isevaluated.
3. Assert:module.[[EvaluationError]] andresult are the sameCompletion Record.
4. Perform ! Call(capability.[[Reject]],undefined, «result.[[Value]] »).
Else,
1. Assert:module.[[Status]] is eitherevaluating-async orevaluated.
2. Assert:module.[[EvaluationError]] isempty.
3. Ifmodule.[[Status]] isevaluated, then
  1. Assert:module.[[AsyncEvaluationOrder]] is eitherunset ordone.
  2. NOTE:module.[[AsyncEvaluationOrder]] isdone if and only ifmodule had already been evaluated and that evaluation was asynchronous.
  3. Perform ! Call(capability.[[Resolve]],undefined, «undefined »).
4. Assert:stack is empty.
Returncapability.[[Promise]].

16.2.1.6.1.3.1 InnerModuleEvaluation (`module`,`stack`,`index` )

The abstract operation InnerModuleEvaluation takes argumentsmodule (aModule Record),stack (aList ofCyclic Module Records), andindex (a non-negativeinteger) and returns either anormal completion containing a non-negativeinteger or athrow completion. It is used by Evaluate to perform the actual evaluation process formodule, as well as recursively on all other modules in the dependency graph. Thestack andindex parameters, as well asmodule's[[DFSAncestorIndex]] field, are used the same way as inInnerModuleLinking. It performs the following steps when called:

Ifmodule is not aCyclic Module Record, then
1. Perform ? EvaluateModuleSync(module).
2. Returnindex.
Ifmodule.[[Status]] is eitherevaluating-async orevaluated, then
1. Ifmodule.[[EvaluationError]] isempty, returnindex.
2. Otherwise, return ? module.[[EvaluationError]].
Ifmodule.[[Status]] isevaluating, returnindex.
Assert:module.[[Status]] islinked.
Setmodule.[[Status]] toevaluating.
LetmoduleIndex beindex.
Setmodule.[[DFSAncestorIndex]] toindex.
Setmodule.[[PendingAsyncDependencies]] to 0.
Setindex toindex + 1.
Appendmodule tostack.
For eachModuleRequest Recordrequest ofmodule.[[RequestedModules]], do
1. LetrequiredModule beGetImportedModule(module,request).
2. Setindex to ? InnerModuleEvaluation(requiredModule,stack,index).
3. IfrequiredModule is aCyclic Module Record, then
  1. Assert:requiredModule.[[Status]] is one ofevaluating,evaluating-async, orevaluated.
  2. Assert:requiredModule.[[Status]] isevaluating if and only ifstack containsrequiredModule.
  3. IfrequiredModule.[[Status]] isevaluating, then
    1. Setmodule.[[DFSAncestorIndex]] tomin(module.[[DFSAncestorIndex]],requiredModule.[[DFSAncestorIndex]]).
  4. Else,
    1. SetrequiredModule torequiredModule.[[CycleRoot]].
    2. Assert:requiredModule.[[Status]] is eitherevaluating-async orevaluated.
    3. IfrequiredModule.[[EvaluationError]] is notempty, return ? requiredModule.[[EvaluationError]].
  5. IfrequiredModule.[[AsyncEvaluationOrder]] is aninteger, then
    1. Setmodule.[[PendingAsyncDependencies]] tomodule.[[PendingAsyncDependencies]] + 1.
    2. Appendmodule torequiredModule.[[AsyncParentModules]].
Ifmodule.[[PendingAsyncDependencies]] > 0 ormodule.[[HasTLA]] istrue, then
1. Assert:module.[[AsyncEvaluationOrder]] isunset.
2. Setmodule.[[AsyncEvaluationOrder]] toIncrementModuleAsyncEvaluationCount().
3. Ifmodule.[[PendingAsyncDependencies]] = 0, performExecuteAsyncModule(module).
Else,
1. Perform ? module.ExecuteModule().
Assert:module occurs exactly once instack.
Assert:module.[[DFSAncestorIndex]] ≤moduleIndex.
Ifmodule.[[DFSAncestorIndex]] =moduleIndex, then
1. Letdone befalse.
2. Repeat, whiledone isfalse,
  1. LetrequiredModule be the last element ofstack.
  2. Remove the last element ofstack.
  3. Assert:requiredModule is aCyclic Module Record.
  4. Assert:requiredModule.[[AsyncEvaluationOrder]] is either aninteger orunset.
  5. IfrequiredModule.[[AsyncEvaluationOrder]] isunset, setrequiredModule.[[Status]] toevaluated.
  6. Otherwise, setrequiredModule.[[Status]] toevaluating-async.
  7. IfrequiredModule andmodule are the sameModule Record, setdone totrue.
  8. SetrequiredModule.[[CycleRoot]] tomodule.
Returnindex.

Note 1

A module isevaluating while it is being traversed by InnerModuleEvaluation. A module isevaluated on execution completion orevaluating-async during execution if its[[HasTLA]] field istrue or if it has asynchronous dependencies.

Note 2

Any modules depending on a module of an asynchronous cycle when that cycle is notevaluating will instead depend on the execution of the root of the cycle via[[CycleRoot]]. This ensures that the cycle state can be treated as a single strongly connected component through its root module state.

16.2.1.6.1.3.2 ExecuteAsyncModule (`module` )

The abstract operation ExecuteAsyncModule takes argumentmodule (aCyclic Module Record) and returnsunused. It performs the following steps when called:

Assert:module.[[Status]] is eitherevaluating orevaluating-async.
Assert:module.[[HasTLA]] istrue.
Letcapability be ! NewPromiseCapability(%Promise%).
LetfulfilledClosure be a newAbstract Closure with no parameters that capturesmodule and performs the following steps when called:
1. PerformAsyncModuleExecutionFulfilled(module).
2. ReturnNormalCompletion(undefined).
LetonFulfilled beCreateBuiltinFunction(fulfilledClosure, 0,"", « »).
LetrejectedClosure be a newAbstract Closure with parameters (error) that capturesmodule and performs the following steps when called:
1. PerformAsyncModuleExecutionRejected(module,error).
2. ReturnNormalCompletion(undefined).
LetonRejected beCreateBuiltinFunction(rejectedClosure, 0,"", « »).
PerformPerformPromiseThen(capability.[[Promise]],onFulfilled,onRejected).
Perform ! module.ExecuteModule(capability).
Returnunused.

16.2.1.6.1.3.3 GatherAvailableAncestors (`module`,`execList` )

The abstract operation GatherAvailableAncestors takes argumentsmodule (aCyclic Module Record) andexecList (aList ofCyclic Module Records) and returnsunused. It performs the following steps when called:

For eachCyclic Module Recordm ofmodule.[[AsyncParentModules]], do
1. IfexecList does not containm andm.[[CycleRoot]].[[EvaluationError]] isempty, then
  1. Assert:m.[[Status]] isevaluating-async.
  2. Assert:m.[[EvaluationError]] isempty.
  3. Assert:m.[[AsyncEvaluationOrder]] is aninteger.
  4. Assert:m.[[PendingAsyncDependencies]] > 0.
  5. Setm.[[PendingAsyncDependencies]] tom.[[PendingAsyncDependencies]] - 1.
  6. Ifm.[[PendingAsyncDependencies]] = 0, then
    1. Appendm toexecList.
    2. Ifm.[[HasTLA]] isfalse, performGatherAvailableAncestors(m,execList).
Returnunused.

Note

When an asynchronous execution for a rootmodule is fulfilled, this function determines the list of modules which are able to synchronously execute together on this completion, populating them inexecList.

16.2.1.6.1.3.4 AsyncModuleExecutionFulfilled (`module` )

The abstract operation AsyncModuleExecutionFulfilled takes argumentmodule (aCyclic Module Record) and returnsunused. It performs the following steps when called:

Ifmodule.[[Status]] isevaluated, then
1. Assert:module.[[EvaluationError]] is notempty.
2. Returnunused.
Assert:module.[[Status]] isevaluating-async.
Assert:module.[[AsyncEvaluationOrder]] is aninteger.
Assert:module.[[EvaluationError]] isempty.
Setmodule.[[AsyncEvaluationOrder]] todone.
Setmodule.[[Status]] toevaluated.
Ifmodule.[[TopLevelCapability]] is notempty, then
1. Assert:module.[[CycleRoot]] andmodule are the sameModule Record.
2. Perform ! Call(module.[[TopLevelCapability]].[[Resolve]],undefined, «undefined »).
LetexecList be a new emptyList.
PerformGatherAvailableAncestors(module,execList).
Assert: All elements ofexecList have their[[AsyncEvaluationOrder]] field set to aninteger,[[PendingAsyncDependencies]] field set to 0, and[[EvaluationError]] field set toempty.
LetsortedExecList be aList whose elements are the elements ofexecList, sorted by their[[AsyncEvaluationOrder]] field in ascending order.
For eachCyclic Module Recordm ofsortedExecList, do
1. Ifm.[[Status]] isevaluated, then
  1. Assert:m.[[EvaluationError]] is notempty.
2. Else ifm.[[HasTLA]] istrue, then
  1. PerformExecuteAsyncModule(m).
3. Else,
  1. Letresult bem.ExecuteModule().
  2. Ifresult is anabrupt completion, then
    1. PerformAsyncModuleExecutionRejected(m,result.[[Value]]).
  3. Else,
    1. Setm.[[AsyncEvaluationOrder]] todone.
    2. Setm.[[Status]] toevaluated.
    3. Ifm.[[TopLevelCapability]] is notempty, then
      1. Assert:m.[[CycleRoot]] andm are the sameModule Record.
      2. Perform ! Call(m.[[TopLevelCapability]].[[Resolve]],undefined, «undefined »).
Returnunused.

16.2.1.6.1.3.5 AsyncModuleExecutionRejected (`module`,`error` )

The abstract operation AsyncModuleExecutionRejected takes argumentsmodule (aCyclic Module Record) anderror (anECMAScript language value) and returnsunused. It performs the following steps when called:

Ifmodule.[[Status]] isevaluated, then
1. Assert:module.[[EvaluationError]] is notempty.
2. Returnunused.
Assert:module.[[Status]] isevaluating-async.
Assert:module.[[AsyncEvaluationOrder]] is aninteger.
Assert:module.[[EvaluationError]] isempty.
Setmodule.[[EvaluationError]] toThrowCompletion(error).
Setmodule.[[Status]] toevaluated.
Setmodule.[[AsyncEvaluationOrder]] todone.
NOTE:module.[[AsyncEvaluationOrder]] is set todone for symmetry withAsyncModuleExecutionFulfilled. InInnerModuleEvaluation, the value of a module's[[AsyncEvaluationOrder]] internal slot is unused when its[[EvaluationError]] internal slot is notempty.
For eachCyclic Module Recordm ofmodule.[[AsyncParentModules]], do
1. PerformAsyncModuleExecutionRejected(m,error).
Ifmodule.[[TopLevelCapability]] is notempty, then
1. Assert:module.[[CycleRoot]] andmodule are the sameModule Record.
2. Perform ! Call(module.[[TopLevelCapability]].[[Reject]],undefined, «error »).
Returnunused.

16.2.1.6.2 Example Cyclic Module Record Graphs

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:

A module graph in which module A depends on module B, and module B depends on module C — Figure 2: A simple module graph

Let's first assume that there are no error conditions. When ahost first callsA.LoadRequestedModules(), this will complete successfully by assumption, and recursively load the dependencies ofB andC as well (respectively,C and none), and then setA.[[Status]] =B.[[Status]] =C.[[Status]] =unlinked. Then, when thehost callsA.Link(), it will complete successfully (again by assumption) such thatA.[[Status]] =B.[[Status]] =C.[[Status]] =linked. These preparatory steps can be performed at any time. Later, when thehost is ready to incur any possible side effects of the modules, it can callA.Evaluate(), which will complete successfully, returning a Promise resolving toundefined (again by assumption), recursively having evaluated firstC and thenB. Each module's[[Status]] at this point will beevaluated.

Consider then cases involving linking errors, after a successful call toA.LoadRequestedModules(). IfInnerModuleLinking ofC succeeds but, thereafter, fails forB, for example because it imports something thatC does not provide, then the originalA.Link() will fail, and bothA andB's[[Status]] remainunlinked.C's[[Status]] has becomelinked, though.

Finally, consider a case involving evaluation errors after a successful call to Link(). IfInnerModuleEvaluation ofC succeeds but, thereafter, fails forB, for example becauseB contains code that throws an exception, then the originalA.Evaluate() will fail, returning a rejected Promise. The resulting exception will be recorded in bothA andB's[[EvaluationError]] fields, and their[[Status]] will becomeevaluated.C will also becomeevaluated but, in contrast toA andB, will remain without an[[EvaluationError]], as it successfully completed evaluation. Storing the exception ensures that any time ahost tries to reuseA orB by calling their Evaluate() method, it will encounter the same exception. (Hosts are not required to reuseCyclic Module Records; similarly,hosts are not required to expose the exception objects thrown by these methods. However, the specification enables such uses.)

Now consider a different type of error condition:

A module graph in which module A depends on a missing (unresolvable) module, represented by ??? — Figure 3: A module graph with an unresolvable module

In this scenario, moduleA declares a dependency on some other module, but noModule Record exists for that module, i.e.HostLoadImportedModule callsFinishLoadingImportedModule with 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 butParseModule returning some errors when trying to parse the resulting source text.Hosts can choose to expose the cause of failure via the completion they pass toFinishLoadingImportedModule. In any case, this exception causes a loading failure, which results inA's[[Status]] remainingnew.

The difference here between loading, linking and evaluation errors is due to the following characteristic:

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.
Loading closely interacts with thehost, and it may be desirable for some of them to allow users to retry failed loads (for example, if the failure is caused by temporarily bad network conditions).

Now, consider a module graph with a cycle:

A module graph in which module A depends on module B and C, but module B also depends on module A — Figure 4: A cyclic module graph

Here we assume that the entry point is moduleA, so that thehost proceeds by callingA.LoadRequestedModules(), which performsInnerModuleLoading onA. This in turn callsInnerModuleLoading onB andC. Because of the cycle, this again triggersInnerModuleLoading onA, but at this point it is a no-op sinceA's dependencies loading has already been triggered during this LoadRequestedModules process. When all the modules in the graph have been successfully loaded, their[[Status]] transitions fromnew tounlinked at the same time.

Then thehost proceeds by callingA.Link(), which performsInnerModuleLinking onA. This in turn callsInnerModuleLinking onB. Because of the cycle, this again triggersInnerModuleLinking onA, but at this point it is a no-op sinceA.[[Status]] is alreadylinking.B.[[Status]] itself remainslinking when control gets back toA andInnerModuleLinking is triggered onC. After this returns withC.[[Status]] beinglinked, bothA andB transition fromlinking tolinked together; this is by design, since they form a strongly connected component. It's possible to transition the status of modules in the same SCC at the same time because during this phase the module graph is traversed with a depth-first search.

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

Now consider a case whereA has a linking error; for example, it tries to import a binding fromC that does not exist. In that case, the above steps still occur, including the early return from the second call toInnerModuleLinking onA. However, once we unwind back to the originalInnerModuleLinking onA, it fails during InitializeEnvironment, namely right afterC.ResolveExport(). The thrownSyntaxError exception propagates up toA.Link, which resets all modules that are currently on itsstack (these are always exactly the modules that are stilllinking). Hence bothA andB becomeunlinked. Note thatC is left aslinked.

Alternatively, consider a case whereA has an evaluation error; for example, its source code throws an exception. In that case, the evaluation-time analogue of the above steps still occurs, including the early return from the second call toInnerModuleEvaluation onA. However, once we unwind back to the originalInnerModuleEvaluation onA, it fails by assumption. The exception thrown propagates up toA.Evaluate(), which records the error in all modules that are currently on itsstack (i.e., the modules that are stillevaluating) as well as via[[AsyncParentModules]], which form a chain for modules which contain or depend on top-levelawait through the whole dependency graph through theAsyncModuleExecutionRejected algorithm. Hence bothA andB becomeevaluated and the exception is recorded in bothA andB's[[EvaluationError]] fields, whileC is left asevaluated with no[[EvaluationError]].

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

A module graph in which module A depends on module B and C, module B depends on module D, module C depends on module D and E, and module D depends on module A — Figure 5: An asynchronous cyclic module graph

Loading and linking happen as before, and all modules end up with[[Status]] set tolinked.

CallingA.Evaluate() callsInnerModuleEvaluation onA,B, andD, which all transition toevaluating. ThenInnerModuleEvaluation is called onA again, which is a no-op because it is alreadyevaluating. At this point,D.[[PendingAsyncDependencies]] is 0, soExecuteAsyncModule(D) is called and we callD.ExecuteModule with a new PromiseCapability tracking the asynchronous execution ofD. We unwind back to theInnerModuleEvaluation onB, settingB.[[PendingAsyncDependencies]] to 1 andB.[[AsyncEvaluationOrder]] to 1. We unwind back to the originalInnerModuleEvaluation onA, settingA.[[PendingAsyncDependencies]] to 1. In the next iteration of the loop overA's dependencies, we callInnerModuleEvaluation onC and thus onD (again a no-op) andE. AsE has no dependencies and is not part of a cycle, we callExecuteAsyncModule(E) in the same manner asD andE is immediately removed from the stack. We unwind once more to theInnerModuleEvaluation onC, settingC.[[AsyncEvaluationOrder]] to 3. Now we finish the loop overA's dependencies, setA.[[AsyncEvaluationOrder]] to 4, and remove the entire strongly connected component from the stack, transitioning all of the modules toevaluating-async at once. At this point, the fields of the modules are as given inTable 46.

Table 46: Module fields after the initial Evaluate() call

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

Let us assume thatE finishes executing first. When that happens,AsyncModuleExecutionFulfilled is called,E.[[Status]] is set toevaluated andC.[[PendingAsyncDependencies]] is decremented to become 1. The fields of the updated modules are as given inTable 47.

Table 47: Module fields after moduleE finishes executing

Field Module	`C`	`E`
`[[DFSAncestorIndex]]`	0	4
`[[Status]]`	evaluating-async	evaluated
`[[AsyncEvaluationOrder]]`	3	done
`[[AsyncParentModules]]`	«`A` »	«`C` »
`[[PendingAsyncDependencies]]`	1 (`D`)	0

D is next to finish (as it was the only module that was still executing). When that happens,AsyncModuleExecutionFulfilled is called again andD.[[Status]] is set toevaluated. Its ancestors available for execution areB (whose[[AsyncEvaluationOrder]] is 1) andC (whose[[AsyncEvaluationOrder]] is 3), thusB will be handled first:B.[[PendingAsyncDependencies]] is decremented to become 0,ExecuteAsyncModule is called onB, and it starts executing.C.[[PendingAsyncDependencies]] is also decremented to become 0, andC starts executing (potentially in parallel toB ifB contains anawait). The fields of the updated modules are as given inTable 48.

Table 48: Module fields after moduleD finishes executing

Field Module	`B`	`C`	`D`
`[[DFSAncestorIndex]]`	0	0	0
`[[Status]]`	evaluating-async	evaluating-async	evaluated
`[[AsyncEvaluationOrder]]`	1	3	done
`[[AsyncParentModules]]`	«`A` »	«`A` »	«`B`,`C` »
`[[PendingAsyncDependencies]]`	0	0	0

Let us assume thatC finishes executing next. When that happens,AsyncModuleExecutionFulfilled is called again,C.[[Status]] is set toevaluated andA.[[PendingAsyncDependencies]] is decremented to become 1. The fields of the updated modules are as given inTable 49.

Table 49: Module fields after moduleC finishes executing

Field Module	`A`	`C`
`[[DFSAncestorIndex]]`	0	0
`[[Status]]`	evaluating-async	evaluated
`[[AsyncEvaluationOrder]]`	4	done
`[[AsyncParentModules]]`	« »	«`A` »
`[[PendingAsyncDependencies]]`	1 (`B`)	0

Then,B finishes executing. When that happens,AsyncModuleExecutionFulfilled is called again andB.[[Status]] is set toevaluated.A.[[PendingAsyncDependencies]] is decremented to become 0, soExecuteAsyncModule is called and it starts executing. The fields of the updated modules are as given inTable 50.

Table 50: Module fields after moduleB finishes executing

Field Module	`A`	`B`
`[[DFSAncestorIndex]]`	0	0
`[[Status]]`	evaluating-async	evaluated
`[[AsyncEvaluationOrder]]`	4	done
`[[AsyncParentModules]]`	« »	«`A` »
`[[PendingAsyncDependencies]]`	0	0

Finally,A finishes executing. When that happens,AsyncModuleExecutionFulfilled is called again andA.[[Status]] is set toevaluated. At this point, the Promise inA.[[TopLevelCapability]] (which was returned fromA.Evaluate()) is resolved, and this concludes the handling of this module graph. The fields of the updated module are as given inTable 51.

Table 51: Module fields after moduleA finishes executing

Field Module	`A`
`[[DFSAncestorIndex]]`	0
`[[Status]]`	evaluated
`[[AsyncEvaluationOrder]]`	done
`[[AsyncParentModules]]`	« »
`[[PendingAsyncDependencies]]`	0

Alternatively, consider a failure case whereC fails execution and returns an error beforeB has finished executing. When that happens,AsyncModuleExecutionRejected is called, which setsC.[[Status]] toevaluated andC.[[EvaluationError]] to the error. It then propagates this error to all of the AsyncParentModules by performingAsyncModuleExecutionRejected on each of them. The fields of the updated modules are as given inTable 52.

Table 52: Module fields after moduleC finishes with an error

Field Module	`A`	`C`
`[[DFSAncestorIndex]]`	0	0
`[[Status]]`	evaluated	evaluated
`[[AsyncEvaluationOrder]]`	done	done
`[[AsyncParentModules]]`	« »	«`A` »
`[[PendingAsyncDependencies]]`	1 (`B`)	0
`[[EvaluationError]]`	empty	`C`'s evaluation error

A will be rejected with the same error asC sinceC will callAsyncModuleExecutionRejected onA withC's error.A.[[Status]] is set toevaluated. At this point the Promise inA.[[TopLevelCapability]] (which was returned fromA.Evaluate()) is rejected. The fields of the updated module are as given inTable 53.

Table 53: Module fields after moduleA is rejected

Field Module	`A`
`[[DFSAncestorIndex]]`	0
`[[Status]]`	evaluated
`[[AsyncEvaluationOrder]]`	done
`[[AsyncParentModules]]`	« »
`[[PendingAsyncDependencies]]`	0
`[[EvaluationError]]`	`C`'sEvaluation Error

Then,B finishes executing without an error. When that happens,AsyncModuleExecutionFulfilled is called again andB.[[Status]] is set toevaluated.GatherAvailableAncestors is called onB. However,A.[[CycleRoot]] isA which has an evaluation error, so it will not be added to the returnedsortedExecList andAsyncModuleExecutionFulfilled will return without further processing. Any future importer ofB will resolve the rejection ofB.[[CycleRoot]].[[EvaluationError]] from the evaluation error fromC that was set on the cycle rootA. The fields of the updated modules are as given inTable 54.

Table 54: Module fields after moduleB finishes executing in an erroring graph

Field Module	`A`	`B`
`[[DFSAncestorIndex]]`	0	0
`[[Status]]`	evaluated	evaluated
`[[AsyncEvaluationOrder]]`	4	1
`[[AsyncParentModules]]`	« »	«`A` »
`[[PendingAsyncDependencies]]`	0	0
`[[EvaluationError]]`	`C`'sEvaluation Error	empty

16.2.1.7 Source Text Module Records

ASource Text Module Record is used to represent information about a module that was defined fromECMAScript source text (11) that was parsed using thegoal symbolModule. Its fields contain digested information about the names that are imported and exported by the module, and its concrete methods use these digests to link and evaluate the module.

ASource Text Module Record can exist in a module graph with other subclasses of the abstractModule Record type, and can participate in cycles with other subclasses of theCyclic Module Record type.

In addition to the fields defined inTable 43,Source Text Module Records have the additional fields listed inTable 55. Each of these fields is initially set inParseModule.

Table 55: Additional Fields ofSource Text Module Records

Field Name	Value Type	Meaning
`[[ECMAScriptCode]]`	aParse Node	The result of parsing the source text of this module usingModule as thegoal symbol.
`[[Context]]`	anECMAScript code execution context orempty	Theexecution context associated with this module. It isempty until the module's environment has been initialized.
`[[ImportMeta]]`	an Object orempty	An object exposed through the`import.meta` meta property. It isempty until it is accessed by ECMAScript code.
`[[ImportEntries]]`	aList ofImportEntry Records	AList of ImportEntry records derived from the code of this module.
`[[LocalExportEntries]]`	aList ofExportEntry Records	AList of ExportEntry records derived from the code of this module that correspond to declarations that occur within the module.
`[[IndirectExportEntries]]`	aList ofExportEntry Records	AList of ExportEntry records derived from the code of this module that correspond to reexported imports that occur within the module or exports from`export * as namespace` declarations.
`[[StarExportEntries]]`	aList ofExportEntry Records	AList of ExportEntry records derived from the code of this module that correspond to`export ` declarations that occur within the module, not including`export as namespace` declarations.

AnImportEntry Record is aRecord that digests information about a single declarative import. EachImportEntry Record has the fields defined inTable 56:

Table 56:ImportEntry Record Fields

Field Name	Value Type	Meaning
`[[ModuleRequest]]`	aModuleRequest Record	ModuleRequest Record representing theModuleSpecifier and import attributes of theImportDeclaration.
`[[ImportName]]`	a String ornamespace-object	The name under which the desired binding is exported by the module identified by`[[ModuleRequest]]`. The valuenamespace-object indicates that the import request is for the target module's namespace object.
`[[LocalName]]`	a String	The name that is used to locally access the imported value from within the importing module.

Note 1

Table 57 gives examples of ImportEntry records fields used to represent the syntactic import forms:

Table 57 (Informative): Import Forms Mappings toImportEntry Records

Import Statement Form	`[[ModuleRequest]]`	`[[ImportName]]`	`[[LocalName]]`
`import v from "mod";`	"mod"	"default"	"v"
`import * as ns from "mod";`	"mod"	namespace-object	"ns"
`import {x} from "mod";`	"mod"	"x"	"x"
`import {x as v} from "mod";`	"mod"	"x"	"v"
`import "mod";`	AnImportEntry Record is not created.

AnExportEntry Record is aRecord that digests information about a single declarative export. EachExportEntry Record has the fields defined inTable 58:

Table 58:ExportEntry Record Fields

Field Name	Value Type	Meaning
`[[ExportName]]`	a String ornull	The name used to export this binding by this module.
`[[ModuleRequest]]`	aModuleRequest Record ornull	TheModuleRequest Record representing theModuleSpecifier and import attributes of theExportDeclaration.null if theExportDeclaration does not have aModuleSpecifier.
`[[ImportName]]`	a String,null,all, orall-but-default	The name under which the desired binding is exported by the module identified by`[[ModuleRequest]]`.null if theExportDeclaration does not have aModuleSpecifier.all is used for`export * as ns from "mod"` declarations.all-but-default is used for`export * from "mod"` declarations.
`[[LocalName]]`	a String ornull	The name that is used to locally access the exported value from within the importing module.null if the exported value is not locally accessible from within the module.

Note 2

Table 59 gives examples of the ExportEntry record fields used to represent the syntactic export forms:

Table 59 (Informative): Export Forms Mappings toExportEntry Records

Export Statement Form	`[[ExportName]]`	`[[ModuleRequest]]`	`[[ImportName]]`	`[[LocalName]]`
`export var v;`	"v"	null	null	"v"
`export default function f() {}`	"default"	null	null	"f"
`export default function () {}`	"default"	null	null	"default"
`export default 42;`	"default"	null	null	"default"
`export {x};`	"x"	null	null	"x"
`export {v as x};`	"x"	null	null	"v"
`export {x} from "mod";`	"x"	"mod"	"x"	null
`export {v as x} from "mod";`	"x"	"mod"	"v"	null
`export * from "mod";`	null	"mod"	all-but-default	null
`export * as ns from "mod";`	"ns"	"mod"	all	null

The following definitions specify the required concrete methods and otherabstract operations forSource Text Module Records

16.2.1.7.1 ParseModule (`sourceText`,`realm`,`hostDefined` )

The abstract operation ParseModule takes argumentssourceText (ECMAScript source text),realm (aRealm Record), andhostDefined (anything) and returns aSource Text Module Record or a non-emptyList ofSyntaxError objects. It creates aSource Text Module Record based upon the result of parsingsourceText as aModule. It performs the following steps when called:

Letbody beParseText(sourceText,Module).
Ifbody is aList of errors, returnbody.
LetrequestedModules be theModuleRequests ofbody.
LetimportEntries be theImportEntries ofbody.
LetimportedBoundNames beImportedLocalNames(importEntries).
LetindirectExportEntries be a new emptyList.
LetlocalExportEntries be a new emptyList.
LetstarExportEntries be a new emptyList.
LetexportEntries be theExportEntries ofbody.
For eachExportEntry Recordee ofexportEntries, do
1. Ifee.[[ModuleRequest]] isnull, then
  1. IfimportedBoundNames does not containee.[[LocalName]], then
    1. Appendee tolocalExportEntries.
  2. Else,
    1. Letie be the element ofimportEntries whose[[LocalName]] isee.[[LocalName]].
    2. Ifie.[[ImportName]] isnamespace-object, then
      1. NOTE: This is a re-export of an imported module namespace object.
      2. Appendee tolocalExportEntries.
    3. Else,
      1. NOTE: This is a re-export of a single name.
      2. Append theExportEntry Record {[[ModuleRequest]]:ie.[[ModuleRequest]],[[ImportName]]:ie.[[ImportName]],[[LocalName]]:null,[[ExportName]]:ee.[[ExportName]] } toindirectExportEntries.
2. Else ifee.[[ImportName]] isall-but-default, then
  1. Assert:ee.[[ExportName]] isnull.
  2. Appendee tostarExportEntries.
3. Else,
  1. Appendee toindirectExportEntries.
Letasync bebodyContainsawait.
ReturnSource Text Module Record {[[Realm]]:realm,[[Environment]]:empty,[[Namespace]]:empty,[[CycleRoot]]:empty,[[HasTLA]]:async,[[AsyncEvaluationOrder]]:unset,[[TopLevelCapability]]:empty,[[AsyncParentModules]]: « »,[[PendingAsyncDependencies]]:empty,[[Status]]:new,[[EvaluationError]]:empty,[[HostDefined]]:hostDefined,[[ECMAScriptCode]]:body,[[Context]]:empty,[[ImportMeta]]:empty,[[RequestedModules]]:requestedModules,[[LoadedModules]]: « »,[[ImportEntries]]:importEntries,[[LocalExportEntries]]:localExportEntries,[[IndirectExportEntries]]:indirectExportEntries,[[StarExportEntries]]:starExportEntries,[[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.

16.2.1.7.2 Implementation of Module Record Abstract Methods

The following are the concrete methods forSource Text Module Record that implement the correspondingModule Record abstract methods defined inTable 42.

16.2.1.7.2.1 GetExportedNames ( [`exportStarSet` ] )

The GetExportedNames concrete method of aSource Text Module Recordmodule takes optional argumentexportStarSet (aList ofSource Text Module Records) and returns aList of Strings. It performs the following steps when called:

Assert:module.[[Status]] is notnew.
IfexportStarSet is not present, setexportStarSet to a new emptyList.
IfexportStarSet containsmodule, then
1. Assert: We've reached the starting point of anexport * circularity.
2. Return a new emptyList.
Appendmodule toexportStarSet.
LetexportedNames be a new emptyList.
For eachExportEntry Recorde ofmodule.[[LocalExportEntries]], do
1. Assert:module provides the direct binding for this export.
2. Assert:e.[[ExportName]] is notnull.
3. Appende.[[ExportName]] toexportedNames.
For eachExportEntry Recorde ofmodule.[[IndirectExportEntries]], do
1. Assert:module imports a specific binding for this export.
2. Assert:e.[[ExportName]] is notnull.
3. Appende.[[ExportName]] toexportedNames.
For eachExportEntry Recorde ofmodule.[[StarExportEntries]], do
1. Assert:e.[[ModuleRequest]] is notnull.
2. LetrequestedModule beGetImportedModule(module,e.[[ModuleRequest]]).
3. LetstarNames berequestedModule.GetExportedNames(exportStarSet).
4. For each elementn ofstarNames, do
  1. Ifn is not"default", then
    1. IfexportedNames does not containn, then
      1. Appendn toexportedNames.
ReturnexportedNames.

Note

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

16.2.1.7.2.2 ResolveExport (`exportName` [ ,`resolveSet` ] )

The ResolveExport concrete method of aSource Text Module Recordmodule takes argumentexportName (a String) and optional argumentresolveSet (aList ofRecords with fields[[Module]] (aModule Record) and[[ExportName]] (a String)) and returns aResolvedBinding Record,null, orambiguous.

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 theModule Record this method was invoked on or some other module that is imported by that module. The parameterresolveSet is used to detect unresolved circular import/export paths. If a pair consisting of specificModule Record andexportName is reached that is already inresolveSet, an import circularity has been encountered. Before recursively calling ResolveExport, a pair consisting ofmodule andexportName is added toresolveSet.

If a defining module is found, aResolvedBinding 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 tonamespace. 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:

Assert:module.[[Status]] is notnew.
IfresolveSet is not present, setresolveSet to a new emptyList.
For eachRecord {[[Module]],[[ExportName]] }r ofresolveSet, do
1. Ifmodule andr.[[Module]] are the sameModule Record andexportName isr.[[ExportName]], then
  1. Assert: This is a circular import request.
  2. Returnnull.
Append theRecord {[[Module]]:module,[[ExportName]]:exportName } toresolveSet.
For eachExportEntry Recorde ofmodule.[[LocalExportEntries]], do
1. Ife.[[ExportName]] isexportName, then
  1. Assert:module provides the direct binding for this export.
  2. ReturnResolvedBinding Record {[[Module]]:module,[[BindingName]]:e.[[LocalName]] }.
For eachExportEntry Recorde ofmodule.[[IndirectExportEntries]], do
1. Ife.[[ExportName]] isexportName, then
  1. Assert:e.[[ModuleRequest]] is notnull.
  2. LetimportedModule beGetImportedModule(module,e.[[ModuleRequest]]).
  3. Ife.[[ImportName]] isall, then
    1. Assert:module does not provide the direct binding for this export.
    2. ReturnResolvedBinding Record {[[Module]]:importedModule,[[BindingName]]:namespace }.
  4. Else,
    1. Assert:module imports a specific binding for this export.
    2. Assert:e.[[ImportName]]is a String.
    3. ReturnimportedModule.ResolveExport(e.[[ImportName]],resolveSet).
IfexportName is"default", then
1. Assert: Adefault export was not explicitly defined by this module.
2. Returnnull.
3. NOTE: Adefault export cannot be provided by anexport * from "mod" declaration.
LetstarResolution benull.
For eachExportEntry Recorde ofmodule.[[StarExportEntries]], do
1. Assert:e.[[ModuleRequest]] is notnull.
2. LetimportedModule beGetImportedModule(module,e.[[ModuleRequest]]).
3. Letresolution beimportedModule.ResolveExport(exportName,resolveSet).
4. Ifresolution isambiguous, returnambiguous.
5. Ifresolution is notnull, then
  1. Assert:resolution is aResolvedBinding Record.
  2. IfstarResolution isnull, then
    1. SetstarResolution toresolution.
  3. Else,
    1. Assert: There is more than one* import that includes the requested name.
    2. Ifresolution.[[Module]] andstarResolution.[[Module]] are not the sameModule Record, returnambiguous.
    3. Ifresolution.[[BindingName]] is notstarResolution.[[BindingName]] and eitherresolution.[[BindingName]] orstarResolution.[[BindingName]] isnamespace, returnambiguous.
    4. Ifresolution.[[BindingName]]is a String,starResolution.[[BindingName]]is a String, andresolution.[[BindingName]] is notstarResolution.[[BindingName]], returnambiguous.
ReturnstarResolution.

16.2.1.7.3 Implementation of Cyclic Module Record Abstract Methods

The following are the concrete methods forSource Text Module Record that implement the correspondingCyclic Module Record abstract methods defined inTable 44.

16.2.1.7.3.1 InitializeEnvironment ( )

The InitializeEnvironment concrete method of aSource Text Module Recordmodule takes no arguments and returns either anormal completion containingunused or athrow completion. It performs the following steps when called:

For eachExportEntry Recorde ofmodule.[[IndirectExportEntries]], do
1. Assert:e.[[ExportName]] is notnull.
2. Letresolution bemodule.ResolveExport(e.[[ExportName]]).
3. Ifresolution is eithernull orambiguous, throw aSyntaxError exception.
4. Assert:resolution is aResolvedBinding Record.
Assert: All named exports frommodule are resolvable.
Letrealm bemodule.[[Realm]].
Assert:realm is notundefined.
Letenv beNewModuleEnvironment(realm.[[GlobalEnv]]).
Setmodule.[[Environment]] toenv.
For eachImportEntry Recordin ofmodule.[[ImportEntries]], do
1. LetimportedModule beGetImportedModule(module,in.[[ModuleRequest]]).
2. Ifin.[[ImportName]] isnamespace-object, then
  1. Letnamespace beGetModuleNamespace(importedModule).
  2. Perform ! env.CreateImmutableBinding(in.[[LocalName]],true).
  3. Perform ! env.InitializeBinding(in.[[LocalName]],namespace).
3. Else,
  1. Letresolution beimportedModule.ResolveExport(in.[[ImportName]]).
  2. Ifresolution is eithernull orambiguous, throw aSyntaxError exception.
  3. Ifresolution.[[BindingName]] isnamespace, then
    1. Letnamespace beGetModuleNamespace(resolution.[[Module]]).
    2. Perform ! env.CreateImmutableBinding(in.[[LocalName]],true).
    3. Perform ! env.InitializeBinding(in.[[LocalName]],namespace).
  4. Else,
    1. PerformCreateImportBinding(env,in.[[LocalName]],resolution.[[Module]],resolution.[[BindingName]]).
LetmoduleContext be a newECMAScript code execution context.
Set the Function ofmoduleContext tonull.
Assert:module.[[Realm]] is notundefined.
Set theRealm ofmoduleContext tomodule.[[Realm]].
Set the ScriptOrModule ofmoduleContext tomodule.
Set the VariableEnvironment ofmoduleContext tomodule.[[Environment]].
Set the LexicalEnvironment ofmoduleContext tomodule.[[Environment]].
Set the PrivateEnvironment ofmoduleContext tonull.
Setmodule.[[Context]] tomoduleContext.
PushmoduleContext onto theexecution context stack;moduleContext is now therunning execution context.
Letcode bemodule.[[ECMAScriptCode]].
LetvarDeclarations be theVarScopedDeclarations ofcode.
LetdeclaredVarNames be a new emptyList.
For each elementd ofvarDeclarations, do
1. For each elementdn of theBoundNames ofd, do
  1. IfdeclaredVarNames does not containdn, then
    1. Perform ! env.CreateMutableBinding(dn,false).
    2. Perform ! env.InitializeBinding(dn,undefined).
    3. Appenddn todeclaredVarNames.
LetlexDeclarations be theLexicallyScopedDeclarations ofcode.
LetprivateEnv benull.
For each elementd oflexDeclarations, do
1. For each elementdn of theBoundNames ofd, do
  1. IfIsConstantDeclaration ofd istrue, then
    1. Perform ! env.CreateImmutableBinding(dn,true).
  2. Else,
    1. Perform ! env.CreateMutableBinding(dn,false).
  3. Ifd is either aFunctionDeclaration, aGeneratorDeclaration, anAsyncFunctionDeclaration, or anAsyncGeneratorDeclaration, then
    1. Letfo beInstantiateFunctionObject ofd with argumentsenv andprivateEnv.
    2. Perform ! env.InitializeBinding(dn,fo).
RemovemoduleContext from theexecution context stack.
Returnunused.

16.2.1.7.3.2 ExecuteModule ( [`capability` ] )

The ExecuteModule concrete method of aSource Text Module Recordmodule takes optional argumentcapability (aPromiseCapability Record) and returns either anormal completion containingunused or athrow completion. It performs the following steps when called:

LetmoduleContext be a newECMAScript code execution context.
Set the Function ofmoduleContext tonull.
Set theRealm ofmoduleContext tomodule.[[Realm]].
Set the ScriptOrModule ofmoduleContext tomodule.
Assert:module has been linked and declarations in its module environment have been instantiated.
Set the VariableEnvironment ofmoduleContext tomodule.[[Environment]].
Set the LexicalEnvironment ofmoduleContext tomodule.[[Environment]].
Suspend therunning execution context.
Ifmodule.[[HasTLA]] isfalse, then
1. Assert:capability is not present.
2. PushmoduleContext onto theexecution context stack;moduleContext is now therunning execution context.
3. Letresult beCompletion(Evaluation ofmodule.[[ECMAScriptCode]]).
4. SuspendmoduleContext and remove it from theexecution context stack.
5. Resume the context that is now on the top of theexecution context stack as therunning execution context.
6. Ifresult is anabrupt completion, then
  1. Return ? result.
Else,
1. Assert:capability is aPromiseCapability Record.
2. PerformAsyncBlockStart(capability,module.[[ECMAScriptCode]],moduleContext).
Returnunused.

16.2.1.8 Synthetic Module Records

ASynthetic Module Record is used to represent information about a module that is defined by specifications. Its exported names are statically defined at creation, while their corresponding values can change over time usingSetSyntheticModuleExport. It has no imports or dependencies.

Note

A Synthetic Module Record could be used for defining a variety of module types: for example, JSON modules or CSS modules.

In addition to the fields defined inTable 41 Synthetic Module Records have the additional fields listed inTable 60.

Table 60: Additional Fields ofSynthetic Module Records

Field Name	Value Type	Meaning
`[[ExportNames]]`	aList of Strings	The names of the exports of the module. This list does not contain duplicates.
`[[EvaluationSteps]]`	anAbstract Closure	The initialization logic to perform upon evaluation of the module, taking theSynthetic Module Record as its sole argument. It must not modify`[[ExportNames]]`. It may return anabrupt completion.

16.2.1.8.1 CreateDefaultExportSyntheticModule (`defaultExport` )

The abstract operation CreateDefaultExportSyntheticModule takes argumentdefaultExport (anECMAScript language value) and returns aSynthetic Module Record. It creates aSynthetic Module Record whose default export isdefaultExport. It performs the following steps when called:

Letrealm bethe current Realm Record.
LetsetDefaultExport be a newAbstract Closure with parameters (module) that capturesdefaultExport and performs the following steps when called:
1. PerformSetSyntheticModuleExport(module,"default",defaultExport).
2. ReturnNormalCompletion(unused).
Return theSynthetic Module Record {[[Realm]]:realm,[[Environment]]:empty,[[Namespace]]:empty,[[HostDefined]]:undefined,[[ExportNames]]: «"default" »,[[EvaluationSteps]]:setDefaultExport }.

16.2.1.8.2 ParseJSONModule (`source` )

The abstract operation ParseJSONModule takes argumentsource (a String) and returns either anormal completion containing aSynthetic Module Record, or athrow completion. It performs the following steps when called:

Letjson be ? ParseJSON(source).
ReturnCreateDefaultExportSyntheticModule(json).

16.2.1.8.3 SetSyntheticModuleExport (`module`,`exportName`,`exportValue` )

The abstract operation SetSyntheticModuleExport takes argumentsmodule (aSynthetic Module Record),exportName (a String), andexportValue (anECMAScript language value) and returnsunused. It can be used to set or change the exported value for an existing export of aSynthetic Module Record. It performs the following steps when called:

Assert:module.[[ExportNames]] containsexportName.
LetenvRec bemodule.[[Environment]].
Assert:envRec is notempty.
PerformenvRec.SetMutableBinding(exportName,exportValue,true).
Returnunused.

16.2.1.8.4 Implementation of Module Record Abstract Methods

The following are the concrete methods forSynthetic Module Record that implement the correspondingModule Record abstract methods defined inTable 42.

16.2.1.8.4.1 LoadRequestedModules ( )

The LoadRequestedModules concrete method of aSynthetic Module Recordmodule takes no arguments and returns a Promise. It performs the following steps when called:

Return ! PromiseResolve(%Promise%,undefined).

Note

Synthetic Module Records have no dependencies.

16.2.1.8.4.2 GetExportedNames ( )

The GetExportedNames concrete method of aSynthetic Module Recordmodule takes no arguments and returns aList of Strings. It performs the following steps when called:

Returnmodule.[[ExportNames]].

16.2.1.8.4.3 ResolveExport (`exportName` )

The ResolveExport concrete method of aSynthetic Module Recordmodule takes argumentexportName (a String) and returns aResolvedBinding Record ornull. It performs the following steps when called:

Ifmodule.[[ExportNames]] does not containexportName, returnnull.
ReturnResolvedBinding Record {[[Module]]:module,[[BindingName]]:exportName }.

16.2.1.8.4.4 Link ( )

The Link concrete method of aSynthetic Module Recordmodule takes no arguments and returns anormal completion containingunused. It performs the following steps when called:

Letrealm bemodule.[[Realm]].
Letenv beNewModuleEnvironment(realm.[[GlobalEnv]]).
Setmodule.[[Environment]] toenv.
For each StringexportName ofmodule.[[ExportNames]], do
1. Perform ! env.CreateMutableBinding(exportName,false).
2. Perform ! env.InitializeBinding(exportName,undefined).
ReturnNormalCompletion(unused).

16.2.1.8.4.5 Evaluate ( )

The Evaluate concrete method of aSynthetic Module Recordmodule takes no arguments and returns a Promise. It performs the following steps when called:

LetmoduleContext be a newECMAScript code execution context.
Set the Function ofmoduleContext tonull.
Set theRealm ofmoduleContext tomodule.[[Realm]].
Set the ScriptOrModule ofmoduleContext tomodule.
Set the VariableEnvironment ofmoduleContext tomodule.[[Environment]].
Set the LexicalEnvironment ofmoduleContext tomodule.[[Environment]].
Suspend therunning execution context.
PushmoduleContext onto theexecution context stack;moduleContext is now therunning execution context.
Letsteps bemodule.[[EvaluationSteps]].
Letresult beCompletion(steps(module)).
SuspendmoduleContext and remove it from theexecution context stack.
Resume the context that is now on the top of theexecution context stack as therunning execution context.
Letpc be ! NewPromiseCapability(%Promise%).
IfAbruptRejectPromise(result,pc).
Perform ! Call(pc.[[Resolve]],undefined, «undefined »).
Returnpc.[[Promise]].

16.2.1.9 GetImportedModule (`referrer`,`request` )

The abstract operation GetImportedModule takes argumentsreferrer (aCyclic Module Record) andrequest (aModuleRequest Record) and returns aModule Record. It performs the following steps when called:

Letrecords be aList consisting of eachLoadedModuleRequest Recordr ofreferrer.[[LoadedModules]] such thatModuleRequestsEqual(r,request) istrue.
Assert:records has exactly one element, since LoadRequestedModules has completed successfully onreferrer prior to invoking this abstract operation.
Letrecord be the sole element ofrecords.
Returnrecord.[[Module]].

16.2.1.10 HostLoadImportedModule (`referrer`,`moduleRequest`,`hostDefined`,`payload` )

Thehost-defined abstract operation HostLoadImportedModule takes argumentsreferrer (aScript Record, aCyclic Module Record, or aRealm Record),moduleRequest (aModuleRequest Record),hostDefined (anything), andpayload (aGraphLoadingState Record or aPromiseCapability Record) and returnsunused.

Note 1

An example of whenreferrer can be aRealm Record is in a web browserhost. There, if a user clicks on a control given by

<buttontype="button"onclick="import('./foo.mjs')">Click me</button>

there will be noactive script or module at the time theimport() expression runs. More generally, this can happen in any situation where thehost pushesexecution contexts withnull ScriptOrModule components onto theexecution context stack.

An implementation of HostLoadImportedModule must conform to the following requirements:

Thehost environment must performFinishLoadingImportedModule(referrer,moduleRequest,payload,result), whereresult is either anormal completion containing the loadedModule Record or athrow completion, either synchronously or asynchronously.
If this operation is called multiple times with two (referrer,moduleRequest) pairs such that:
- the firstreferrer is the same as the secondreferrer;
- ModuleRequestsEqual(the firstmoduleRequest, the secondmoduleRequest) istrue;
and it performsFinishLoadingImportedModule(referrer,moduleRequest,payload,result) whereresult is anormal completion, then it must performFinishLoadingImportedModule(referrer,moduleRequest,payload,result) with the sameresult each time.
IfmoduleRequest.[[Attributes]] has an entryentry such thatentry.[[Key]] is"type" andentry.[[Value]] is"json", when thehost environment performsFinishLoadingImportedModule(referrer,moduleRequest,payload,result),result must either be theCompletion Record returned by an invocation ofParseJSONModule or athrow completion.
The operation must treatpayload as an opaque value to be passed through toFinishLoadingImportedModule.

The actual process performed ishost-defined, but typically consists of performing whatever I/O operations are necessary to load the appropriateModule Record. Multiple different (referrer,moduleRequest.[[Specifier]],moduleRequest.[[Attributes]]) triples may map to the sameModule Record instance. The actual mapping semantics ishost-defined but typically a normalization process is applied tospecifier as part of the mapping process. A typical normalization process would include actions such as expansion of relative and abbreviated path specifiers.

Note 2

The above text requires thathosts support JSON modules when imported withtype: "json" (and HostLoadImportedModule completes normally), but it does not prohibithosts from supporting JSON modules when imported withouttype: "json".

16.2.1.11 FinishLoadingImportedModule (`referrer`,`moduleRequest`,`payload`,`result` )

The abstract operation FinishLoadingImportedModule takes argumentsreferrer (aScript Record, aCyclic Module Record, or aRealm Record),moduleRequest (aModuleRequest Record),payload (aGraphLoadingState Record or aPromiseCapability Record), andresult (either anormal completion containing aModule Record or athrow completion) and returnsunused. It performs the following steps when called:

Ifresult is anormal completion, then
1. Ifreferrer.[[LoadedModules]] contains aLoadedModuleRequest Recordrecord such thatModuleRequestsEqual(record,moduleRequest) istrue, then
  1. Assert:record.[[Module]] andresult.[[Value]] are the sameModule Record.
2. Else,
  1. Append theLoadedModuleRequest Record {[[Specifier]]:moduleRequest.[[Specifier]],[[Attributes]]:moduleRequest.[[Attributes]],[[Module]]:result.[[Value]] } toreferrer.[[LoadedModules]].
Ifpayload is aGraphLoadingState Record, then
1. PerformContinueModuleLoading(payload,result).
Else,
1. PerformContinueDynamicImport(payload,result).
Returnunused.

16.2.1.12 AllImportAttributesSupported (`attributes` )

The abstract operation AllImportAttributesSupported takes argumentattributes (aList ofImportAttribute Records) and returns a Boolean. It performs the following steps when called:

Letsupported beHostGetSupportedImportAttributes().
For eachImportAttribute Recordattribute ofattributes, do
1. Ifsupported does not containattribute.[[Key]], returnfalse.
Returntrue.

16.2.1.12.1 HostGetSupportedImportAttributes ( )

Thehost-defined abstract operation HostGetSupportedImportAttributes takes no arguments and returns aList of Strings. It allowshost environments to specify which import attributes they support. Only attributes with supported keys will be provided to thehost.

An implementation of HostGetSupportedImportAttributes must conform to the following requirements:

It must return aList of Strings, each indicating a supported attribute.
Each time this operation is called, it must return the sameList with the same contents in the same order.

The default implementation of HostGetSupportedImportAttributes is to return a new emptyList.

Note

The purpose of requiring thehost to specify its supported import attributes, rather than passing all attributes to thehost and letting it then choose which ones it wants to handle, is to ensure that unsupported attributes are handled in a consistent way across differenthosts.

16.2.1.13 GetModuleNamespace (`module` )

The abstract operation GetModuleNamespace takes argumentmodule (an instance of a concrete subclass ofModule Record) and returns a Module Namespace Object. It retrieves the Module Namespace Object representingmodule's exports, lazily creating it the first time it was requested, and storing it inmodule.[[Namespace]] for future retrieval. It performs the following steps when called:

Assert: Ifmodule is aCyclic Module Record, thenmodule.[[Status]] is notnew orunlinked.
Letnamespace bemodule.[[Namespace]].
Ifnamespace isempty, then
1. LetexportedNames bemodule.GetExportedNames().
2. LetunambiguousNames be a new emptyList.
3. For each elementname ofexportedNames, do
  1. Letresolution bemodule.ResolveExport(name).
  2. Ifresolution is aResolvedBinding Record, appendname tounambiguousNames.
4. Setnamespace toModuleNamespaceCreate(module,unambiguousNames).
Returnnamespace.

Note

GetModuleNamespace never throws. Instead, unresolvable names are simply excluded from the namespace at this point. They will lead to a real linking error later unless they are all ambiguous star exports that are not explicitly requested anywhere.

16.2.1.14 Runtime Semantics: Evaluation

[empty]

Returnundefined.

ModuleBody

Letresult beCompletion(Evaluation ofModuleItemList).
Ifresult is anormal completion andresult.[[Value]] isempty, then
1. Returnundefined.
Return ? result.

Letsl be ? Evaluation ofModuleItemList.
Lets beCompletion(Evaluation ofModuleItem).
Return ? UpdateEmpty(s,sl).

Note

The value of aModuleItemList is the value of the last value-producing item in theModuleItemList.

Returnempty.

16.2.2 Imports

Syntax

import

opt

;

import

opt

;

{

}

{

ImportsList

}

{

}

from

[~Yield, +Await]

with

{

}

with

{

opt

}

16.2.2.1 Static Semantics: Early Errors

It is a Syntax Error if theBoundNames ofImportDeclaration contains any duplicate entries.

with

{

opt

}

It is a Syntax Error ifWithClauseToAttributes ofWithClause has two different entriesa andb such thata.[[Key]] isb.[[Key]].

16.2.2.2 Static Semantics: ImportEntries

Thesyntax-directed operation ImportEntries takes no arguments and returns aList ofImportEntry Records. It is defined piecewise over the following productions:

[empty]

Return a new emptyList.

Letentries1 be theImportEntries ofModuleItemList.
Letentries2 be theImportEntries ofModuleItem.
Return thelist-concatenation ofentries1 andentries2.

Return a new emptyList.

import

opt

;

Letmodule be the sole element of theModuleRequests ofImportDeclaration.
Return theImportEntriesForModule ofImportClause with argumentmodule.

import

opt

;

Return a new emptyList.

16.2.2.3 Static Semantics: ImportEntriesForModule

Thesyntax-directed operation ImportEntriesForModule takes argumentmodule (aModuleRequest Record) and returns aList ofImportEntry Records. It is defined piecewise over the following productions:

Letentries1 be theImportEntriesForModule ofImportedDefaultBinding with argumentmodule.
Letentries2 be theImportEntriesForModule ofNameSpaceImport with argumentmodule.
Return thelist-concatenation ofentries1 andentries2.

Letentries1 be theImportEntriesForModule ofImportedDefaultBinding with argumentmodule.
Letentries2 be theImportEntriesForModule ofNamedImports with argumentmodule.
Return thelist-concatenation ofentries1 andentries2.

LetlocalName be the sole element of theBoundNames ofImportedBinding.
LetdefaultEntry be theImportEntry Record {[[ModuleRequest]]:module,[[ImportName]]:"default",[[LocalName]]:localName }.
Return «defaultEntry ».

LetlocalName be theStringValue ofImportedBinding.
Letentry be theImportEntry Record {[[ModuleRequest]]:module,[[ImportName]]:namespace-object,[[LocalName]]:localName }.
Return «entry ».

{

}

Return a new emptyList.

ImportsList

ImportSpecifier

Letspecs1 be theImportEntriesForModule ofImportsList with argumentmodule.
Letspecs2 be theImportEntriesForModule ofImportSpecifier with argumentmodule.
Return thelist-concatenation ofspecs1 andspecs2.

ImportSpecifier

LetlocalName be the sole element of theBoundNames ofImportedBinding.
Letentry be theImportEntry Record {[[ModuleRequest]]:module,[[ImportName]]:localName,[[LocalName]]:localName }.
Return «entry ».

ImportSpecifier

LetimportName be theStringValue ofModuleExportName.
LetlocalName be theStringValue ofImportedBinding.
Letentry be theImportEntry Record {[[ModuleRequest]]:module,[[ImportName]]:importName,[[LocalName]]:localName }.
Return «entry ».

16.2.2.4 Static Semantics: WithClauseToAttributes

Thesyntax-directed operation WithClauseToAttributes takes no arguments and returns aList ofImportAttribute Records. It is defined piecewise over the following productions:

with

{

}

Return a new emptyList.

with

{

opt

}

Letattributes beWithClauseToAttributes ofWithEntries.
Sortattributes 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. NOTE: This sorting is observable only in thathosts are prohibited from changing behaviour based on the order in which attributes are enumerated.
Returnattributes.

AttributeKey

Letkey be thePropName ofAttributeKey.
Letentry be theImportAttribute Record {[[Key]]:key,[[Value]]: theSV ofStringLiteral }.
Return «entry ».

Letkey be thePropName ofAttributeKey.
Letentry be theImportAttribute Record {[[Key]]:key,[[Value]]: theSV ofStringLiteral }.
Letrest beWithClauseToAttributes ofWithEntries.
Return thelist-concatenation of «entry » andrest.

16.2.3 Exports

Syntax

export

opt

;

export

;

export

[~Yield, +Await]

export

[~Yield, +Await]

export

default

[~Yield, +Await, +Default]

export

default

[~Yield, +Await, +Default]

export

default

[lookahead ∉ {function,async

[noLineTerminator here]

function,class }]

[+In, ~Yield, +Await]

;

{

}

{

}

{

}

16.2.3.1 Static Semantics: Early Errors

export

;

It is a Syntax Error if theReferencedBindings ofNamedExports contains anyStringLiterals.
For eachIdentifierNamen in theReferencedBindings ofNamedExports: It is a Syntax Error if theStringValue ofn is aReservedWord or theStringValue ofn is one of"implements","interface","let","package","private","protected","public", or"static".

Note

The above rule means that eachReferencedBindings ofNamedExports is treated as anIdentifierReference.

16.2.3.2 Static Semantics: ExportedBindings

Thesyntax-directed operation ExportedBindings takes no arguments and returns aList of Strings.

Note

ExportedBindings are the locally bound names that are explicitly associated with aModule'sExportedNames.

It is defined piecewise over the following productions:

Letnames1 be theExportedBindings ofModuleItemList.
Letnames2 be theExportedBindings ofModuleItem.
Return thelist-concatenation ofnames1 andnames2.

Return a new emptyList.

export

opt

;

Return a new emptyList.

export

;

Return theExportedBindings ofNamedExports.

export

Return theBoundNames ofVariableStatement.

export

Return theBoundNames ofDeclaration.

export

default

export

default

export

default

;

Return theBoundNames of thisExportDeclaration.

{

}

Return a new emptyList.

Letnames1 be theExportedBindings ofExportsList.
Letnames2 be theExportedBindings ofExportSpecifier.
Return thelist-concatenation ofnames1 andnames2.

Return aList whose sole element is theStringValue ofModuleExportName.

Return aList whose sole element is theStringValue of the firstModuleExportName.

16.2.3.3 Static Semantics: ExportedNames

Thesyntax-directed operation ExportedNames takes no arguments and returns aList of Strings.

Note

ExportedNames are the externally visible names that aModule explicitly maps to one of its local name bindings.

It is defined piecewise over the following productions:

Letnames1 be theExportedNames ofModuleItemList.
Letnames2 be theExportedNames ofModuleItem.
Return thelist-concatenation ofnames1 andnames2.

Return theExportedNames ofExportDeclaration.

Return a new emptyList.

export

opt

;

Return theExportedNames ofExportFromClause.

Return a new emptyList.

Return aList whose sole element is theStringValue ofModuleExportName.

Return theExportedNames ofNamedExports.

export

Return theBoundNames ofVariableStatement.

export

Return theBoundNames ofDeclaration.

export

default

export

default

export

default

;

Return «"default" ».

{

}

Return a new emptyList.

Letnames1 be theExportedNames ofExportsList.
Letnames2 be theExportedNames ofExportSpecifier.
Return thelist-concatenation ofnames1 andnames2.

Return aList whose sole element is theStringValue ofModuleExportName.

Return aList whose sole element is theStringValue of the secondModuleExportName.

16.2.3.4 Static Semantics: ExportEntries

Thesyntax-directed operation ExportEntries takes no arguments and returns aList ofExportEntry Records. It is defined piecewise over the following productions:

[empty]

Return a new emptyList.

Letentries1 be theExportEntries ofModuleItemList.
Letentries2 be theExportEntries ofModuleItem.
Return thelist-concatenation ofentries1 andentries2.

Return a new emptyList.

export

opt

;

Letmodule be the sole element of theModuleRequests ofExportDeclaration.
Return theExportEntriesForModule ofExportFromClause with argumentmodule.

export

;

Return theExportEntriesForModule ofNamedExports with argumentnull.

export

Letentries be a new emptyList.
Letnames be theBoundNames ofVariableStatement.
For each elementname ofnames, do
1. Append theExportEntry Record {[[ModuleRequest]]:null,[[ImportName]]:null,[[LocalName]]:name,[[ExportName]]:name } toentries.
Returnentries.

export

Letentries be a new emptyList.
Letnames be theBoundNames ofDeclaration.
For each elementname ofnames, do
1. Append theExportEntry Record {[[ModuleRequest]]:null,[[ImportName]]:null,[[LocalName]]:name,[[ExportName]]:name } toentries.
Returnentries.

export

default

Letnames be theBoundNames ofHoistableDeclaration.
LetlocalName be the sole element ofnames.
Return aList whose sole element is a newExportEntry Record {[[ModuleRequest]]:null,[[ImportName]]:null,[[LocalName]]:localName,[[ExportName]]:"default" }.

export

default

Letnames be theBoundNames ofClassDeclaration.
LetlocalName be the sole element ofnames.
Return aList whose sole element is a newExportEntry Record {[[ModuleRequest]]:null,[[ImportName]]:null,[[LocalName]]:localName,[[ExportName]]:"default" }.

export

default

;

Letentry be theExportEntry Record {[[ModuleRequest]]:null,[[ImportName]]:null,[[LocalName]]:"*default*",[[ExportName]]:"default" }.
Return «entry ».

Note

"*default*" is used within this specification as a synthetic name for anonymous default export values. Seethis note for more details.

16.2.3.5 Static Semantics: ExportEntriesForModule

Thesyntax-directed operation ExportEntriesForModule takes argumentmodule (aModuleRequest Record ornull) and returns aList ofExportEntry Records. It is defined piecewise over the following productions:

Letentry be theExportEntry Record {[[ModuleRequest]]:module,[[ImportName]]:all-but-default,[[LocalName]]:null,[[ExportName]]:null }.
Return «entry ».

LetexportName be theStringValue ofModuleExportName.
Letentry be theExportEntry Record {[[ModuleRequest]]:module,[[ImportName]]:all,[[LocalName]]:null,[[ExportName]]:exportName }.
Return «entry ».

{

}

Return a new emptyList.

Letspecs1 be theExportEntriesForModule ofExportsList with argumentmodule.
Letspecs2 be theExportEntriesForModule ofExportSpecifier with argumentmodule.
Return thelist-concatenation ofspecs1 andspecs2.

LetsourceName be theStringValue ofModuleExportName.
Ifmodule isnull, then
1. LetlocalName besourceName.
2. LetimportName benull.
Else,
1. LetlocalName benull.
2. LetimportName besourceName.
Return aList whose sole element is a newExportEntry Record {[[ModuleRequest]]:module,[[ImportName]]:importName,[[LocalName]]:localName,[[ExportName]]:sourceName }.

LetsourceName be theStringValue of the firstModuleExportName.
LetexportName be theStringValue of the secondModuleExportName.
Ifmodule isnull, then
1. LetlocalName besourceName.
2. LetimportName benull.
Else,
1. LetlocalName benull.
2. LetimportName besourceName.
Return aList whose sole element is a newExportEntry Record {[[ModuleRequest]]:module,[[ImportName]]:importName,[[LocalName]]:localName,[[ExportName]]:exportName }.

16.2.3.6 Static Semantics: ReferencedBindings

Thesyntax-directed operation ReferencedBindings takes no arguments and returns aList ofParse Nodes. It is defined piecewise over the following productions:

{

}

Return a new emptyList.

Letnames1 be theReferencedBindings ofExportsList.
Letnames2 be theReferencedBindings ofExportSpecifier.
Return thelist-concatenation ofnames1 andnames2.

Return theReferencedBindings of the firstModuleExportName.

IdentifierName

Return aList whose sole element is theIdentifierName.

Return aList whose sole element is theStringLiteral.

16.2.3.7 Runtime Semantics: Evaluation

export

opt

;

export

;

Returnempty.

export

Return ? Evaluation ofVariableStatement.

export

Return ? Evaluation ofDeclaration.

export

default

Return ? Evaluation ofHoistableDeclaration.

export

default

Letvalue be ? BindingClassDeclarationEvaluation ofClassDeclaration.
LetclassName be the sole element of theBoundNames ofClassDeclaration.
IfclassName is"*default*", then
1. Letenv be therunning execution context's LexicalEnvironment.
2. Perform ? InitializeBoundName("*default*",value,env).
Returnempty.

export

default