16.2 Modules
Syntax
16.2.1 Module Semantics
16.2.1.1 Static Semantics: Early Errors
-
It is a Syntax Error if the
LexicallyDeclaredNames ofModuleItemList contains any duplicate entries. -
It is a Syntax Error if any element of the
LexicallyDeclaredNames ofModuleItemList also occurs in theVarDeclaredNames ofModuleItemList . -
It is a Syntax Error if the
ExportedNames ofModuleItemList contains any duplicate entries. -
It is a Syntax Error if any element of the
ExportedBindings ofModuleItemList does not also occur in either theVarDeclaredNames ofModuleItemList , or theLexicallyDeclaredNames ofModuleItemList . -
It is a Syntax Error if
ModuleItemList Contains super
. -
It is a Syntax Error if
ModuleItemList Contains NewTarget . -
It is a Syntax Error if
ContainsDuplicateLabels ofModuleItemList with argument « » istrue . -
It is a Syntax Error if
ContainsUndefinedBreakTarget ofModuleItemList with argument « » istrue . -
It is a Syntax Error if
ContainsUndefinedContinueTarget ofModuleItemList with arguments « » and « » istrue .
The duplicate export default
16.2.1.2 Static Semantics: ImportedLocalNames ( importEntries )
The abstract operation ImportedLocalNames takes argument importEntries (a
- Let localNames be a new empty
List . - For each
ImportEntry Record i of importEntries, do- Append i.[[LocalName]] to localNames.
- Return localNames.
16.2.1.3 Static Semantics: ModuleRequests
- Return a new empty
List .
- Return
ModuleRequests ofModuleItem .
- Let moduleNames be
ModuleRequests ofModuleItemList . - Let additionalNames be
ModuleRequests ofModuleItem . - Append to moduleNames each element of additionalNames that is not already an element of moduleNames.
- Return moduleNames.
- Return a new empty
List .
- Return
ModuleRequests ofFromClause .
- Return a
List whose sole element is theSV ofStringLiteral .
- Return the
ModuleRequests ofFromClause .
- Return a new empty
List .
16.2.1.4 Abstract Module Records
A Module 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 the
Module Record defines the fields listed in
Field Name | Value Type | Meaning |
---|---|---|
[[Realm]] |
|
The |
[[Environment]] |
|
The |
[[Namespace]] |
Object | |
The Module Namespace Object ( |
[[HostDefined]] |
Any, default value is |
Field reserved for use by |
Method | Purpose |
---|---|
GetExportedNames([exportStarSet]) | Return a list of all names that are either directly or indirectly exported from this module. |
ResolveExport(exportName [, resolveSet]) |
Return the binding of a name exported by this module. Bindings are represented by a ResolvedBinding Record, of the form { [[Module]]: Each time this operation is called with a specific exportName, resolveSet pair as arguments it must return the same result if it completes normally. |
Link() |
Prepare the module for evaluation by transitively resolving all module dependencies and creating a |
Evaluate() |
If this module has already been evaluated successfully, return Link must have completed successfully prior to invoking this method. |
16.2.1.5 Cyclic Module Records
A Cyclic Module Record is used to represent information about a module that can participate in dependency cycles with other modules that are subclasses of the
In addition to the fields defined in
Field Name | Value Type | Meaning |
---|---|---|
[[Status]] |
|
Initially |
[[EvaluationError]] |
An |
A completion of type |
[[DFSIndex]] |
|
Auxiliary field used during Link and Evaluate only.
If [[Status]] is |
[[DFSAncestorIndex]] |
|
Auxiliary field used during Link and Evaluate only. If [[Status]] is |
[[RequestedModules]] |
|
A |
In addition to the methods defined in
Method | Purpose |
---|---|
|
Initialize the |
|
Evaluate the module's code within its |
16.2.1.5.1 Link ( ) Concrete Method
The Link concrete method of a
Assert : module.[[Status]] is notlinking orevaluating .- Let stack be a new empty
List . - Let result be
InnerModuleLinking (module, stack, 0). - If result is an
abrupt completion , then- For each
Cyclic Module Record m of stack, doAssert : m.[[Status]] islinking .- Set m.[[Status]] to
unlinked . - Set m.[[Environment]] to
undefined . - Set m.[[DFSIndex]] to
undefined . - Set m.[[DFSAncestorIndex]] to
undefined .
Assert : module.[[Status]] isunlinked .- Return result.
- For each
Assert : module.[[Status]] islinked orevaluated .Assert : stack is empty.- Return
undefined .
16.2.1.5.1.1 InnerModuleLinking ( module, stack, index )
The abstract operation InnerModuleLinking takes arguments module (a
- If module is not a
Cyclic Module Record , then- Perform ? module.Link().
- Return index.
- If module.[[Status]] is
linking ,linked , orevaluated , then- Return index.
Assert : module.[[Status]] isunlinked .- Set module.[[Status]] to
linking . - Set module.[[DFSIndex]] to index.
- Set module.[[DFSAncestorIndex]] to index.
- Set index to index + 1.
- Append module to stack.
- For each String required of module.[[RequestedModules]], do
- Let requiredModule be ?
HostResolveImportedModule (module, required). - Set index to ?
InnerModuleLinking (requiredModule, stack, index). - If requiredModule is a
Cyclic Module Record , thenAssert : requiredModule.[[Status]] is eitherlinking ,linked , orevaluated .Assert : requiredModule.[[Status]] islinking if and only if requiredModule is in stack.- If requiredModule.[[Status]] is
linking , then- Set module.[[DFSAncestorIndex]] to
min (module.[[DFSAncestorIndex]], requiredModule.[[DFSAncestorIndex]]).
- Set module.[[DFSAncestorIndex]] to
- Let requiredModule be ?
- Perform ? module.
InitializeEnvironment (). Assert : module occurs exactly once in stack.Assert : module.[[DFSAncestorIndex]] ≤ module.[[DFSIndex]].- If module.[[DFSAncestorIndex]] = module.[[DFSIndex]], then
- Let done be
false . - Repeat, while done is
false ,- Let requiredModule be the last element in stack.
- Remove the last element of stack.
Assert : requiredModule is aCyclic Module Record .- Set requiredModule.[[Status]] to
linked . - If requiredModule and module are the same
Module Record , set done totrue .
- Let done be
- Return index.
16.2.1.5.2 Evaluate ( ) Concrete Method
The Evaluate concrete method of a
Assert : This call to Evaluate is not happening at the same time as another call to Evaluate within thesurrounding agent .Assert : module.[[Status]] islinked orevaluated .- Let stack be a new empty
List . - Let result be
InnerModuleEvaluation (module, stack, 0). - If result is an
abrupt completion , then- For each
Cyclic Module Record m of stack, doAssert : m.[[Status]] isevaluating .- Set m.[[Status]] to
evaluated . - Set m.[[EvaluationError]] to result.
Assert : module.[[Status]] isevaluated and module.[[EvaluationError]] is result.- Return result.
- For each
Assert : module.[[Status]] isevaluated and module.[[EvaluationError]] isundefined .Assert : stack is empty.- Return
undefined .
16.2.1.5.2.1 InnerModuleEvaluation ( module, stack, index )
The abstract operation InnerModuleEvaluation takes arguments module (a
- If module is not a
Cyclic Module Record , then- Perform ? module.Evaluate().
- Return index.
- If module.[[Status]] is
evaluated , then- If module.[[EvaluationError]] is
undefined , return index. - Otherwise, return module.[[EvaluationError]].
- If module.[[EvaluationError]] is
- If module.[[Status]] is
evaluating , return index. Assert : module.[[Status]] islinked .- Set module.[[Status]] to
evaluating . - Set module.[[DFSIndex]] to index.
- Set module.[[DFSAncestorIndex]] to index.
- Set index to index + 1.
- Append module to stack.
- For each String required of module.[[RequestedModules]], do
- Let requiredModule be !
HostResolveImportedModule (module, required). - NOTE: Link must be completed successfully prior to invoking this method, so every requested module is guaranteed to resolve successfully.
- Set index to ?
InnerModuleEvaluation (requiredModule, stack, index). - If requiredModule is a
Cyclic Module Record , thenAssert : requiredModule.[[Status]] is eitherevaluating orevaluated .Assert : requiredModule.[[Status]] isevaluating if and only if requiredModule is in stack.- If requiredModule.[[Status]] is
evaluating , then- Set module.[[DFSAncestorIndex]] to
min (module.[[DFSAncestorIndex]], requiredModule.[[DFSAncestorIndex]]).
- Set module.[[DFSAncestorIndex]] to
- Let requiredModule be !
- Perform ? module.
ExecuteModule (). Assert : module occurs exactly once in stack.Assert : module.[[DFSAncestorIndex]] ≤ module.[[DFSIndex]].- If module.[[DFSAncestorIndex]] = module.[[DFSIndex]], then
- Let done be
false . - Repeat, while done is
false ,- Let requiredModule be the last element in stack.
- Remove the last element of stack.
Assert : requiredModule is aCyclic Module Record .- Set requiredModule.[[Status]] to
evaluated . - If requiredModule and module are the same
Module Record , set done totrue .
- Let done be
- Return index.
16.2.1.5.3 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:
Let's first assume that there are no error conditions. When a
Consider then cases involving linking errors. If
Finally, consider a case involving evaluation errors. If
The difference here between linking and evaluation errors is due to how evaluation must be only performed once, as it can cause side effects; it is thus important to remember whether evaluation has already been performed, even if unsuccessfully. (In the error case, it makes sense to also remember the exception because otherwise subsequent Evaluate() calls would have to synthesize a new one.) Linking, on the other hand, is side-effect-free, and thus even if it fails, it can be retried at a later time with no issues.
Now consider a different type of error condition:
In this scenario, module A declares a dependency on some other module, but no
Lastly, consider a module graph with a cycle:
Here we assume that the entry point is module A, so that the
An analogous story occurs for the evaluation phase of a cyclic module graph, in the success case.
Now consider a case where A has an linking error; for example, it tries to import a binding from C that does not exist. In that case, the above steps still occur, including the early return from the second call to
Finally, consider a case where A has an evaluation error; for example, its source code throws an exception. In that case, the evaluation-time analog of the above steps still occurs, including the early return from the second call to
16.2.1.6 Source Text Module Records
A Source Text Module Record is used to represent information about a module that was defined from ECMAScript source text (
A
In addition to the fields defined in
Field Name | Value Type | Meaning |
---|---|---|
[[ECMAScriptCode]] |
a |
The result of parsing the source text of this module using |
[[Context]] |
An ECMAScript |
The |
[[ImportMeta]] | Object |
An object exposed through the import.meta meta property. It is |
[[ImportEntries]] |
|
A |
[[LocalExportEntries]] |
|
A |
[[IndirectExportEntries]] |
|
A export * as namespace declarations.
|
[[StarExportEntries]] |
|
A export * declarations that occur within the module, not including export * as namespace declarations.
|
An ImportEntry Record is a
Field Name | Value Type | Meaning |
---|---|---|
[[ModuleRequest]] | String |
String value of the |
[[ImportName]] | String |
The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. The value |
[[LocalName]] | String | The name that is used to locally access the imported value from within the importing module. |
Import Statement Form | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
---|---|---|---|
import v from "mod";
|
|
|
|
import * as ns from "mod";
|
|
|
|
import {x} from "mod";
|
|
|
|
import {x as v} from "mod";
|
|
|
|
import "mod";
|
An |
An ExportEntry Record is a
Field Name | Value Type | Meaning |
---|---|---|
[[ExportName]] | String | null | The name used to export this binding by this module. |
[[ModuleRequest]] | String | null |
The String value of the |
[[ImportName]] | String | null |
The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. |
[[LocalName]] | String | null |
The name that is used to locally access the exported value from within the importing module. |
Export Statement Form | [[ExportName]] | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
---|---|---|---|---|
export var v;
|
|
|
|
|
export default function f() {}
|
|
|
|
|
export default function () {}
|
|
|
|
|
export default 42;
|
|
|
|
|
export {x};
|
|
|
|
|
export {v as x};
|
|
|
|
|
export {x} from "mod";
|
|
|
|
|
export {v as x} from "mod";
|
|
|
|
|
export * from "mod";
|
|
|
|
|
export * as ns from "mod";
|
|
|
|
|
The following definitions specify the required concrete methods and other
16.2.1.6.1 ParseModule ( sourceText, realm, hostDefined )
The abstract operation ParseModule takes arguments sourceText (ECMAScript source text), realm, and hostDefined. It creates a
Assert : sourceText is an ECMAScript source text (see clause11 ).- Let body be
ParseText (sourceText,Module ). - If body is a
List of errors, return body. - Let requestedModules be the
ModuleRequests of body. - Let importEntries be
ImportEntries of body. - Let importedBoundNames be
ImportedLocalNames (importEntries). - Let indirectExportEntries be a new empty
List . - Let localExportEntries be a new empty
List . - Let starExportEntries be a new empty
List . - Let exportEntries be
ExportEntries of body. - For each
ExportEntry Record ee of exportEntries, do- If ee.[[ModuleRequest]] is
null , then- If ee.[[LocalName]] is not an element of importedBoundNames, then
- Append ee to localExportEntries.
- Else,
- Let ie be the element of importEntries whose [[LocalName]] is the same as ee.[[LocalName]].
- If ie.[[ImportName]] is
"*" , then- NOTE: This is a re-export of an imported module namespace object.
- Append ee to localExportEntries.
- Else,
- NOTE: This is a re-export of a single name.
- Append the
ExportEntry Record { [[ModuleRequest]]: ie.[[ModuleRequest]], [[ImportName]]: ie.[[ImportName]], [[LocalName]]:null , [[ExportName]]: ee.[[ExportName]] } to indirectExportEntries.
- If ee.[[LocalName]] is not an element of importedBoundNames, then
- Else if ee.[[ImportName]] is
"*" and ee.[[ExportName]] isnull , then- Append ee to starExportEntries.
- Else,
- Append ee to indirectExportEntries.
- If ee.[[ModuleRequest]] is
- Return
Source Text Module Record { [[Realm]]: realm, [[Environment]]:undefined , [[Namespace]]:undefined , [[Status]]:unlinked , [[EvaluationError]]:undefined , [[HostDefined]]: hostDefined, [[ECMAScriptCode]]: body, [[Context]]:empty , [[ImportMeta]]:empty , [[RequestedModules]]: requestedModules, [[ImportEntries]]: importEntries, [[LocalExportEntries]]: localExportEntries, [[IndirectExportEntries]]: indirectExportEntries, [[StarExportEntries]]: starExportEntries, [[DFSIndex]]:undefined , [[DFSAncestorIndex]]:undefined }.
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.6.2 GetExportedNames ( [ exportStarSet ] ) Concrete Method
The GetExportedNames concrete method of a
- If exportStarSet is not present, set exportStarSet to a new empty
List . Assert : exportStarSet is aList of Source Text Module Records.- If exportStarSet contains module, then
- Append module to exportStarSet.
- Let exportedNames be a new empty
List . - For each
ExportEntry Record e of module.[[LocalExportEntries]], doAssert : module provides the direct binding for this export.- Append e.[[ExportName]] to exportedNames.
- For each
ExportEntry Record e of module.[[IndirectExportEntries]], doAssert : module imports a specific binding for this export.- Append e.[[ExportName]] to exportedNames.
- For each
ExportEntry Record e of module.[[StarExportEntries]], do- Let requestedModule be ?
HostResolveImportedModule (module, e.[[ModuleRequest]]). - Let starNames be ? requestedModule.GetExportedNames(exportStarSet).
- For each element n of starNames, do
- If
SameValue (n,"default" ) isfalse , then- If n is not an element of exportedNames, then
- Append n to exportedNames.
- If n is not an element of exportedNames, then
- If
- Let requestedModule be ?
- Return exportedNames.
GetExportedNames does not filter out or throw an exception for names that have ambiguous star export bindings.
16.2.1.6.3 ResolveExport ( exportName [ , resolveSet ] ) Concrete Method
The ResolveExport concrete method of a
ResolveExport attempts to resolve an imported binding to the actual defining module and local binding name. The defining module may be the module represented by the
If a defining module is found, a
This concrete method performs the following steps when called:
- If resolveSet is not present, set resolveSet to a new empty
List . Assert : resolveSet is aList ofRecord { [[Module]], [[ExportName]] }.- For each
Record { [[Module]], [[ExportName]] } r of resolveSet, do- If module and r.[[Module]] are the same
Module Record andSameValue (exportName, r.[[ExportName]]) istrue , thenAssert : This is a circular import request.- Return
null .
- If module and r.[[Module]] are the same
- Append the
Record { [[Module]]: module, [[ExportName]]: exportName } to resolveSet. - For each
ExportEntry Record e of module.[[LocalExportEntries]], do- If
SameValue (exportName, e.[[ExportName]]) istrue , thenAssert : module provides the direct binding for this export.- Return
ResolvedBinding Record { [[Module]]: module, [[BindingName]]: e.[[LocalName]] }.
- If
- For each
ExportEntry Record e of module.[[IndirectExportEntries]], do- If
SameValue (exportName, e.[[ExportName]]) istrue , then- Let importedModule be ?
HostResolveImportedModule (module, e.[[ModuleRequest]]). - If e.[[ImportName]] is
"*" , thenAssert : module does not provide the direct binding for this export.- Return
ResolvedBinding Record { [[Module]]: importedModule, [[BindingName]]:"*namespace*" }.
- Else,
Assert : module imports a specific binding for this export.- Return importedModule.ResolveExport(e.[[ImportName]], resolveSet).
- Let importedModule be ?
- If
- If
SameValue (exportName,"default" ) istrue , thenAssert : Adefault
export was not explicitly defined by this module.- Return
null . - NOTE: A
default
export cannot be provided by anexport *
orexport * from "mod"
declaration.
- Let starResolution be
null . - For each
ExportEntry Record e of module.[[StarExportEntries]], do- Let importedModule be ?
HostResolveImportedModule (module, e.[[ModuleRequest]]). - Let resolution be ? importedModule.ResolveExport(exportName, resolveSet).
- If resolution is
"ambiguous" , return"ambiguous" . - If resolution is not
null , thenAssert : resolution is aResolvedBinding Record .- If starResolution is
null , set starResolution to resolution. - Else,
Assert : There is more than one*
import that includes the requested name.- If resolution.[[Module]] and starResolution.[[Module]] are not the same
Module Record orSameValue (resolution.[[BindingName]], starResolution.[[BindingName]]) isfalse , return"ambiguous" .
- Let importedModule be ?
- Return starResolution.
16.2.1.6.4 InitializeEnvironment ( ) Concrete Method
The InitializeEnvironment concrete method of a
- For each
ExportEntry Record e of module.[[IndirectExportEntries]], do- Let resolution be ? module.ResolveExport(e.[[ExportName]]).
- If resolution is
null or"ambiguous" , throw aSyntaxError exception. Assert : resolution is aResolvedBinding Record .
Assert : All named exports from module are resolvable.- Let realm be module.[[Realm]].
Assert : realm is notundefined .- Let env be
NewModuleEnvironment (realm.[[GlobalEnv]]). - Set module.[[Environment]] to env.
- For each
ImportEntry Record in of module.[[ImportEntries]], do- Let importedModule be !
HostResolveImportedModule (module, in.[[ModuleRequest]]). - NOTE: The above call cannot fail because imported module requests are a subset of module.[[RequestedModules]], and these have been resolved earlier in this algorithm.
- If in.[[ImportName]] is
"*" , then- Let namespace be ?
GetModuleNamespace (importedModule). - Perform ! env.CreateImmutableBinding(in.[[LocalName]],
true ). - Call env.InitializeBinding(in.[[LocalName]], namespace).
- Let namespace be ?
- Else,
- Let resolution be ? importedModule.ResolveExport(in.[[ImportName]]).
- If resolution is
null or"ambiguous" , throw aSyntaxError exception. - If resolution.[[BindingName]] is
"*namespace*" , then- Let namespace be ?
GetModuleNamespace (resolution.[[Module]]). - Perform ! env.CreateImmutableBinding(in.[[LocalName]],
true ). - Call env.InitializeBinding(in.[[LocalName]], namespace).
- Let namespace be ?
- Else,
- Call env.CreateImportBinding(in.[[LocalName]], resolution.[[Module]], resolution.[[BindingName]]).
- Let importedModule be !
- Let moduleContext be a new ECMAScript code
execution context . - Set the Function of moduleContext to
null . Assert : module.[[Realm]] is notundefined .- Set the
Realm of moduleContext to module.[[Realm]]. - Set the ScriptOrModule of moduleContext to module.
- Set the VariableEnvironment of moduleContext to module.[[Environment]].
- Set the LexicalEnvironment of moduleContext to module.[[Environment]].
- Set module.[[Context]] to moduleContext.
- Push moduleContext onto the
execution context stack ; moduleContext is now therunning execution context . - Let code be module.[[ECMAScriptCode]].
- Let varDeclarations be the
VarScopedDeclarations of code. - Let declaredVarNames be a new empty
List . - For each element d of varDeclarations, do
- For each element dn of the
BoundNames of d, do- If dn is not an element of declaredVarNames, then
- Perform ! env.CreateMutableBinding(dn,
false ). - Call env.InitializeBinding(dn,
undefined ). - Append dn to declaredVarNames.
- Perform ! env.CreateMutableBinding(dn,
- If dn is not an element of declaredVarNames, then
- For each element dn of the
- Let lexDeclarations be the
LexicallyScopedDeclarations of code. - For each element d of lexDeclarations, do
- For each element dn of the
BoundNames of d, do- If
IsConstantDeclaration of d istrue , then- Perform ! env.CreateImmutableBinding(dn,
true ).
- Perform ! env.CreateImmutableBinding(dn,
- Else,
- Perform ! env.CreateMutableBinding(dn,
false ).
- Perform ! env.CreateMutableBinding(dn,
- If d is a
FunctionDeclaration , aGeneratorDeclaration , anAsyncFunctionDeclaration , or anAsyncGeneratorDeclaration , then- Let fo be
InstantiateFunctionObject of d with argument env. - Call env.InitializeBinding(dn, fo).
- Let fo be
- If
- For each element dn of the
- Remove moduleContext from the
execution context stack . - Return
NormalCompletion (empty ).
16.2.1.6.5 ExecuteModule ( ) Concrete Method
The ExecuteModule concrete method of a
- Suspend the currently
running execution context . - Let moduleContext be module.[[Context]].
- Push moduleContext onto the
execution context stack ; moduleContext is now therunning execution context . - Let result be the result of evaluating module.[[ECMAScriptCode]].
- Suspend moduleContext and remove it from the
execution context stack . - Resume the context that is now on the top of the
execution context stack as therunning execution context . - Return
Completion (result).
16.2.1.7 HostResolveImportedModule ( referencingScriptOrModule, specifier )
The import()
An example of when referencingScriptOrModule can be
<button type="button" onclick="import('./foo.mjs')">Click me</button>
there will be no import()
The implementation of HostResolveImportedModule must conform to the following requirements:
-
The normal return value must be an instance of a concrete subclass of
Module Record . -
If a
Module Record corresponding to the pair referencingScriptOrModule, specifier does not exist or cannot be created, an exception must be thrown. -
Each time this operation is called with a specific referencingScriptOrModule, specifier pair as arguments it must return the same
Module Record instance if it completes normally.
Multiple different referencingScriptOrModule, specifier pairs may map to the same
16.2.1.8 HostImportModuleDynamically ( referencingScriptOrModule, specifier, promiseCapability )
The import()
The implementation of HostImportModuleDynamically must conform to the following requirements:
-
The abstract operation must always complete normally with
undefined . Success or failure must instead be signaled as discussed below. -
The
host environment must conform to one of the two following sets of requirements:- Success path
-
- At some future time, the
host environment must performFinishDynamicImport (referencingScriptOrModule, specifier, promiseCapability,NormalCompletion (undefined )). - Any subsequent call to
HostResolveImportedModule afterFinishDynamicImport has completed, given the arguments referencingScriptOrModule and specifier, must complete normally. - The completion value of any subsequent call to
HostResolveImportedModule afterFinishDynamicImport has completed, given the arguments referencingScriptOrModule and specifier, must be a module which has already been evaluated, i.e. whose Evaluate concrete method has already been called and returned a normal completion.
- At some future time, the
- Failure path
-
- At some future time, the
host environment must performFinishDynamicImport (referencingScriptOrModule, specifier, promiseCapability, anabrupt completion ), with theabrupt completion representing the cause of failure.
- At some future time, the
-
If the
host environment takes the success path once for a given referencingScriptOrModule, specifier pair, it must always do so for subsequent calls. -
The operation must not call promiseCapability.[[Resolve]] or promiseCapability.[[Reject]], but instead must treat promiseCapability as an opaque identifying value to be passed through to
FinishDynamicImport .
The actual process performed is
16.2.1.9 FinishDynamicImport ( referencingScriptOrModule, specifier, promiseCapability, completion )
The abstract operation FinishDynamicImport takes arguments referencingScriptOrModule, specifier, promiseCapability (a import()
- If completion is an
abrupt completion , perform !Call (promiseCapability.[[Reject]],undefined , « completion.[[Value]] »). - Else,
Assert : completion is a normal completion and completion.[[Value]] isundefined .- Let moduleRecord be !
HostResolveImportedModule (referencingScriptOrModule, specifier). Assert : Evaluate has already been invoked on moduleRecord and successfully completed.- Let namespace be
GetModuleNamespace (moduleRecord). - If namespace is an
abrupt completion , perform !Call (promiseCapability.[[Reject]],undefined , « namespace.[[Value]] »). - Else, perform !
Call (promiseCapability.[[Resolve]],undefined , « namespace.[[Value]] »).
16.2.1.10 GetModuleNamespace ( module )
The abstract operation GetModuleNamespace takes argument module. It retrieves the Module Namespace Object representing module's exports, lazily creating it the first time it was requested, and storing it in module.[[Namespace]] for future retrieval. It performs the following steps when called:
Assert : module is an instance of a concrete subclass ofModule Record .Assert : If module is aCyclic Module Record , then module.[[Status]] is notunlinked .- Let namespace be module.[[Namespace]].
- If namespace is
undefined , then- Let exportedNames be ? module.GetExportedNames().
- Let unambiguousNames be a new empty
List . - For each element name of exportedNames, do
- Let resolution be ? module.ResolveExport(name).
- If resolution is a
ResolvedBinding Record , append name to unambiguousNames.
- Set namespace to
ModuleNamespaceCreate (module, unambiguousNames).
- Return namespace.
The only way GetModuleNamespace can throw is via one of the triggered
16.2.1.11 Runtime Semantics: Evaluation
- Return
NormalCompletion (undefined ).
- Let result be the result of evaluating
ModuleItemList . - If result.[[Type]] is
normal and result.[[Value]] isempty , then- Return
NormalCompletion (undefined ).
- Return
- Return
Completion (result).
- Let sl be the result of evaluating
ModuleItemList . ReturnIfAbrupt (sl).- Let s be the result of evaluating
ModuleItem . - Return
Completion (UpdateEmpty (s, sl)).
The value of a
- Return
NormalCompletion (empty ).
16.2.2 Imports
Syntax
16.2.2.1 Static Semantics: Early Errors
-
It is a Syntax Error if the
BoundNames ofImportDeclaration contains any duplicate entries.
16.2.2.2 Static Semantics: ImportEntries
- Return a new empty
List .
- Let entries be
ImportEntries ofModuleItemList . - Append to entries the elements of the
ImportEntries ofModuleItem . - Return entries.
- Return a new empty
List .
- Let module be the sole element of
ModuleRequests ofFromClause . - Return
ImportEntriesForModule ofImportClause with argument module.
- Return a new empty
List .
16.2.2.3 Static Semantics: ImportEntriesForModule
With parameter module.
- Let entries be
ImportEntriesForModule ofImportedDefaultBinding with argument module. - Append to entries the elements of the
ImportEntriesForModule ofNameSpaceImport with argument module. - Return entries.
- Let entries be
ImportEntriesForModule ofImportedDefaultBinding with argument module. - Append to entries the elements of the
ImportEntriesForModule ofNamedImports with argument module. - Return entries.
- Let localName be the sole element of
BoundNames ofImportedBinding . - Let defaultEntry be the
ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]:"default" , [[LocalName]]: localName }. - Return a
List whose sole element is defaultEntry.
- Let localName be the
StringValue ofImportedBinding . - Let entry be the
ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]:"*" , [[LocalName]]: localName }. - Return a
List whose sole element is entry.
- Return a new empty
List .
- Let specs be the
ImportEntriesForModule ofImportsList with argument module. - Append to specs the elements of the
ImportEntriesForModule ofImportSpecifier with argument module. - Return specs.
- Let localName be the sole element of
BoundNames ofImportedBinding . - Let entry be the
ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: localName, [[LocalName]]: localName }. - Return a
List whose sole element is entry.
- Let importName be the
StringValue ofIdentifierName . - Let localName be the
StringValue ofImportedBinding . - Let entry be the
ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName }. - Return a
List whose sole element is entry.
16.2.3 Exports
Syntax
16.2.3.1 Static Semantics: Early Errors
-
For each
IdentifierName n inReferencedBindings ofNamedExports : It is a Syntax Error ifStringValue of n is aReservedWord or if theStringValue of n is one of:"implements" ,"interface" ,"let" ,"package" ,"private" ,"protected" ,"public" , or"static" .
The above rule means that each
16.2.3.2 Static Semantics: ExportedBindings
ExportedBindings are the locally bound names that are explicitly associated with a
- Let names be
ExportedBindings ofModuleItemList . - Append to names the elements of the
ExportedBindings ofModuleItem . - Return names.
- Return a new empty
List .
- Return a new empty
List .
- Return the
ExportedBindings ofNamedExports .
- Return the
BoundNames ofVariableStatement .
- Return the
BoundNames ofDeclaration .
- Return the
BoundNames of thisExportDeclaration .
- Return a new empty
List .
- Let names be the
ExportedBindings ofExportsList . - Append to names the elements of the
ExportedBindings ofExportSpecifier . - Return names.
- Return a
List whose sole element is theStringValue ofIdentifierName .
- Return a
List whose sole element is theStringValue of the firstIdentifierName .
16.2.3.3 Static Semantics: ExportedNames
ExportedNames are the externally visible names that a
- Let names be
ExportedNames ofModuleItemList . - Append to names the elements of the
ExportedNames ofModuleItem . - Return names.
- Return the
ExportedNames ofExportDeclaration .
- Return a new empty
List .
- Return the
ExportedNames ofExportFromClause .
- Return a new empty
List .
- Return a
List whose sole element is theStringValue ofIdentifierName .
- Return the
ExportedNames ofNamedExports .
- Return the
BoundNames ofVariableStatement .
- Return the
BoundNames ofDeclaration .
- Return «
"default" ».
- Return a new empty
List .
- Let names be the
ExportedNames ofExportsList . - Append to names the elements of the
ExportedNames ofExportSpecifier . - Return names.
- Return a
List whose sole element is theStringValue ofIdentifierName .
- Return a
List whose sole element is theStringValue of the secondIdentifierName .
16.2.3.4 Static Semantics: ExportEntries
- Return a new empty
List .
- Let entries be
ExportEntries ofModuleItemList . - Append to entries the elements of the
ExportEntries ofModuleItem . - Return entries.
- Return a new empty
List .
- Let module be the sole element of
ModuleRequests ofFromClause . - Return
ExportEntriesForModule ofExportFromClause with argument module.
- Return
ExportEntriesForModule ofNamedExports with argumentnull .
- Let entries be a new empty
List . - Let names be the
BoundNames ofVariableStatement . - For each element name of names, do
- Append the
ExportEntry Record { [[ModuleRequest]]:null , [[ImportName]]:null , [[LocalName]]: name, [[ExportName]]: name } to entries.
- Append the
- Return entries.
- Let entries be a new empty
List . - Let names be the
BoundNames ofDeclaration . - For each element name of names, do
- Append the
ExportEntry Record { [[ModuleRequest]]:null , [[ImportName]]:null , [[LocalName]]: name, [[ExportName]]: name } to entries.
- Append the
- Return entries.
- Let names be
BoundNames ofHoistableDeclaration . - Let localName be the sole element of names.
- Return a
List whose sole element is theExportEntry Record { [[ModuleRequest]]:null , [[ImportName]]:null , [[LocalName]]: localName, [[ExportName]]:"default" }.
- Let names be
BoundNames ofClassDeclaration . - Let localName be the sole element of names.
- Return a
List whose sole element is theExportEntry Record { [[ModuleRequest]]:null , [[ImportName]]:null , [[LocalName]]: localName, [[ExportName]]:"default" }.
- Let entry be the
ExportEntry Record { [[ModuleRequest]]:null , [[ImportName]]:null , [[LocalName]]:"*default*" , [[ExportName]]:"default" }. - Return a
List whose sole element is entry.
16.2.3.5 Static Semantics: ExportEntriesForModule
With parameter module.
- Let entry be the
ExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]:"*" , [[LocalName]]:null , [[ExportName]]:null }. - Return a
List whose sole element is entry.
- Let exportName be the
StringValue ofIdentifierName . - Let entry be the
ExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]:"*" , [[LocalName]]:null , [[ExportName]]: exportName }. - Return a
List whose sole element is entry.
- Return a new empty
List .
- Let specs be the
ExportEntriesForModule ofExportsList with argument module. - Append to specs the elements of the
ExportEntriesForModule ofExportSpecifier with argument module. - Return specs.
- Let sourceName be the
StringValue ofIdentifierName . - If module is
null , then- Let localName be sourceName.
- Let importName be
null .
- Else,
- Let localName be
null . - Let importName be sourceName.
- Let localName be
- Return a
List whose sole element is theExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName, [[ExportName]]: sourceName }.
- Let sourceName be the
StringValue of the firstIdentifierName . - Let exportName be the
StringValue of the secondIdentifierName . - If module is
null , then- Let localName be sourceName.
- Let importName be
null .
- Else,
- Let localName be
null . - Let importName be sourceName.
- Let localName be
- Return a
List whose sole element is theExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName, [[ExportName]]: exportName }.
16.2.3.6 Static Semantics: ReferencedBindings
- Return a new empty
List .
- Let names be the
ReferencedBindings ofExportsList . - Append to names the elements of the
ReferencedBindings ofExportSpecifier . - Return names.
- Return a
List whose sole element is theIdentifierName .
- Return a
List whose sole element is the firstIdentifierName .
16.2.3.7 Runtime Semantics: Evaluation
- Return
NormalCompletion (empty ).
- Return the result of evaluating
VariableStatement .
- Return the result of evaluating
Declaration .
- Return the result of evaluating
HoistableDeclaration .
- Let value be ?
BindingClassDeclarationEvaluation ofClassDeclaration . - Let className be the sole element of
BoundNames ofClassDeclaration . - If className is
"*default*" , then- Let env be the
running execution context 's LexicalEnvironment. - Perform ?
InitializeBoundName ("*default*" , value, env).
- Let env be the
- Return
NormalCompletion (empty ).
- If
IsAnonymousFunctionDefinition (AssignmentExpression ) istrue , then- Let value be ?
NamedEvaluation ofAssignmentExpression with argument"default" .
- Let value be ?
- Else,
- Let rhs be the result of evaluating
AssignmentExpression . - Let value be ?
GetValue (rhs).
- Let rhs be the result of evaluating
- Let env be the
running execution context 's LexicalEnvironment. - Perform ?
InitializeBoundName ("*default*" , value, env). - Return
NormalCompletion (empty ).