ECMA-262 (12th Edition) ECMAScript 2021 Language Specification - page 28

realm

.[[GlobalEnv]]).

6. Set

module

.[[Environment]] to

env

7. For each

module

.[[ImportEntries]], do

a. Let

importedModule

be !

(

module

.[[ModuleRequest]]).

b. 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.

c. If

.[[ImportName]] is

"*"

, then

i. Let

namespace

be ?

GetModuleNamespace

importedModule

ii. Perform !

env

.CreateImmutableBinding(

.[[LocalName]],

true

iii. Call

env

.InitializeBinding(

.[[LocalName]],

namespace

d. Else,

i. Let

resolution

be ?

importedModule

.ResolveExport(

.[[ImportName]]).

ii. If

resolution

null

"ambiguous"

, throw a

SyntaxError

exception.

iii. If

resolution

.[[BindingName]] is

"*namespace*"

, then

1. Let

namespace

be ?

GetModuleNamespace

resolution

.[[Module]]).

2. Perform !

env

.CreateImmutableBinding(

.[[LocalName]],

true

3. Call

env

.InitializeBinding(

.[[LocalName]],

namespace

iv. Else,

1. Call

env

.CreateImportBinding(

.[[LocalName]],

resolution

.[[Module]],

resolution

[[BindingName]]).

8. Let

moduleContext

be a new ECMAScript code

execution context

9. Set the Function of

moduleContext

null

10.

module

.[[Realm]] is not

undefined

11. Set the

Realm

moduleContext

module

.[[Realm]].

12. Set the ScriptOrModule of

moduleContext

module

13. Set the VariableEnvironment of

moduleContext

module

.[[Environment]].

14. Set the LexicalEnvironment of

moduleContext

module

.[[Environment]].

15. Set

module

.[[Context]] to

moduleContext

16. Push

moduleContext

onto the

;

moduleContext

is now the

17. Let

code

module

.[[ECMAScriptCode]].

18. Let

varDeclarations

VarScopedDeclarations

code

19. Let

declaredVarNames

be a new empty

20. For each element

varDeclarations

, do

a. For each element

of the

LexicallyScopedDeclarations

, do

i. If

is not an element of

declaredVarNames

, then

1. Perform !

env

.CreateMutableBinding(

false

2. Call

env

.InitializeBinding(

undefined

3. Append

declaredVarNames

21. Let

lexDeclarations

be the

code

22. For each element

lexDeclarations

, do

a. For each element

of the

AsyncFunctionDeclaration

, do

i. If

IsConstantDeclaration

true

, then

1. Perform !

env

.CreateImmutableBinding(

true

ii. Else,

1. Perform !

env

.CreateMutableBinding(

false

iii. If

is a

FunctionDeclaration

, a

GeneratorDeclaration

, an

, or an

AsyncGeneratorDeclaration

, then

1. Let

InstantiateFunctionObject

with argument

env

448

2. Call

env

.InitializeBinding(

23. Remove

moduleContext

from the

24. Return

Source Text Module Record

(

empty

The ExecuteModule concrete method of a

module

takes no arguments. It performs the

following steps when called:

1. Suspend the currently

2. Let

moduleContext

module

.[[Context]].

3. Push

moduleContext

onto the

;

moduleContext

is now the

4. Let

result

be the result of evaluating

module

.[[ECMAScriptCode]].

5. Suspend

moduleContext

and remove it from the

6. Resume the context that is now on the top of the

as the

7. Return

Completion

(

result

The

abstract operation HostResolveImportedModule takes arguments

referencingScriptOrModule

String). It provides the concrete

subclass instance that corresponds to

specifier

occurring within the context of the script or module represented by

referencingScriptOrModule

may be

null

if the resolution is being performed in the context of

expression and there is no

active script or module

at that time.

NOTE

The implementation of HostResolveImportedModule must conform to the following requirements:

The normal return value must be an instance of a concrete subclass of

If a

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

instance if it completes normally.

Multiple different

referencingScriptOrModule

specifier

pairs may map to the same

instance. The actual

mapping semantic is

but typically a normalization process is applied to

specifier

as part of the mapping

process. A typical normalization process would include actions such as alphabetic case folding and expansion of
relative and abbreviated path specifiers.

An example of when

referencingScriptOrModule

can be

null

is in a web browser

. There, if a

user clicks on a control given by

there will be no

active script or module

at the time the

expression runs. More

generally, this can happen in any situation where the

pushes execution contexts with

null

ScriptOrModule components onto the

button

type

"button"

onclick

"import('./foo.mjs')"

>Click me</

button

16.2.1.6.5 ExecuteModule ( ) Concrete Method

16.2.1.7 HostResolveImportedModule (

referencingScriptOrModule

specifier

)

16.2.1.8 HostImportModuleDynamically (

referencingScriptOrModule

specifier

promiseCapability

)

449

The

). It performs any necessary setup work in order to make available the module corresponding to

abstract operation HostImportModuleDynamically takes arguments

referencingScriptOrModule

specifier

occurring within the context of the script or module represented by

referencingScriptOrModule

may be

null

if there is no

active script or module

when the

expression occurs. It

then performs

to finish the dynamic import process.

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

referencingScriptOrModule

specifier

promiseCapability

undefined

)).

Any subsequent call to

after

The completion value of any subsequent call to

has completed,

given the arguments

referencingScriptOrModule

and

specifier

, must complete normally.

after

referencingScriptOrModule

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.

Failure path

At some future time, the

representing the cause of failure.

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

The actual process performed is

, but typically consists of performing whatever I/O operations are

necessary to allow

to synchronously retrieve the appropriate

, and then

calling its Evaluate concrete method. This might require performing similar normalization as

does.

The abstract operation FinishDynamicImport takes arguments

referencingScriptOrModule

specifier

promiseCapability

PromiseCapability Record

), and

completion

. FinishDynamicImport completes the process of a dynamic import

originally started by an

call, resolving or rejecting the promise returned by that call as appropriate

according to

completion

. It is performed by

HostImportModuleDynamically

environments as part of

. It performs

the following steps when called:

1. If

completion

is an

abrupt completion

, perform !

Call

(

promiseCapability

.[[Reject]],

undefined

, «

completion

[[Value]] »).

2. Else,

completion

is a normal completion and

completion

.[[Value]] is

undefined

16.2.1.9 FinishDynamicImport (

referencingScriptOrModule

specifier

promiseCapability

completion

)

450

b. Let

moduleRecord

be !

(

referencingScriptOrModule

specifier

: Evaluate has already been invoked on

moduleRecord

and successfully completed.

d. Let

namespace

GetModuleNamespace

moduleRecord

e. If

namespace

, perform !

promiseCapability

.[[Reject]],

undefined

, «

namespace

[[Value]] »).

f. Else, perform !

Call

promiseCapability

.[[Resolve]],

undefined

, «

namespace

.[[Value]] »).

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:

module

is an instance of a concrete subclass of

: If

module

is a

Cyclic Module Record

, then

module

.[[Status]] is not

unlinked

3. Let

namespace

module

.[[Namespace]].

4. If

namespace

undefined

, then

a. Let

exportedNames

be ?

module

.GetExportedNames().

b. Let

unambiguousNames

be a new empty

c. For each element

name

exportedNames

, do

i. Let

resolution

be ?

module

.ResolveExport(

name

ii. If

resolution

is a

ResolvedBinding Record

, append

name

unambiguousNames

d. Set

namespace

ModuleNamespaceCreate

(

module

unambiguousNames

5. Return

namespace

NOTE

[empty]

1. Return

(

undefined

ModuleBody

1. Let

result

be the result of evaluating

2. If

result

.[[Type]] is

normal

and

result

.[[Value]] is

empty

, then

a. Return

(

undefined

3. Return

Completion

(

result

1. Let

be the result of evaluating

ReturnIfAbrupt

3. Let

be the result of evaluating

4. Return

(

)).

The only way GetModuleNamespace can throw is via one of the triggered

calls. 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.10 GetModuleNamespace (

module

)

16.2.1.11 Runtime Semantics: Evaluation

451

ImportDeclaration

It is a Syntax Error if the

contains any duplicate entries.

ImportDeclaration

[empty]

1. Return a new empty

1. Let

entries

ImportEntries

2. Append to

entries

the elements of the

ImportEntries

3. Return

entries

ExportDeclaration
StatementListItem

1. Return a new empty

import

;

1. Let

module

be the sole element of

ModuleRequests

FromClause

2. Return

ImportClause

with argument

module

ImportDeclaration

import

ModuleSpecifier

;

1. Return a new empty

With parameter

module

ImportClause

NameSpaceImport

1. Let

entries

with argument

module

2. Append to

entries

the elements of the

NameSpaceImport

with argument

module

3. Return

entries

ImportClause

NamedImports

1. Let

entries

with argument

module

2. Append to

entries

the elements of the

NamedImports

with argument

module

3. Return

entries

1. Let

localName

be the sole element of

2. Let

defaultEntry

{ [[ModuleRequest]]:

module

, [[ImportName]]:

"default"

[[LocalName]]:

localName

whose sole element is

defaultEntry

16.2.2.1 Static Semantics: Early Errors

16.2.2.2 Static Semantics: ImportEntries

16.2.2.3 Static Semantics: ImportEntriesForModule

453

NameSpaceImport

1. Let

localName

be the

2. Let

entry

module

, [[ImportName]]:

"*"

, [[LocalName]]:

localName

whose sole element is

entry

NamedImports

{

}

1. Return a new empty

ImportsList

1. Let

specs

be the

ImportsList

with argument

module

2. Append to

specs

the elements of the

with argument

module

3. Return

specs

1. Let

localName

be the sole element of

2. Let

entry

module

, [[ImportName]]:

localName

, [[LocalName]]:

localName

whose sole element is

entry

1. Let

importName

2. Let

localName

be the

3. Let

entry

module

, [[ImportName]]:

importName

, [[LocalName]]:

localName

4. Return a

whose sole element is

entry

export

FromClause

;

export

;

export

[~Yield, ~Await]

export

[~Yield, ~Await]

export

default

[~Yield, ~Await, +Default]

export

default

[~Yield, ~Await, +Default]

export

default

[lookahead

∉

{

function

async

[no

LineTerminator

here]

function

class

}]

[+In, ~Yield, ~Await]

;

16.2.3 Exports

Syntax

454

1. Let

entries

ExportEntries

2. Append to

entries

the elements of the

ExportEntries

3. Return

entries

ImportDeclaration
StatementListItem

1. Return a new empty

export

;

1. Let

module

be the sole element of

ModuleRequests

FromClause

2. Return

with argument

module

export

;

1. Return

with argument

null

export

1. Let

entries

be a new empty

2. Let

names

3. For each element

name

names

, do

a. Append the

{ [[ModuleRequest]]:

null

, [[ImportName]]:

null

, [[LocalName]]:

name

[[ExportName]]:

name

} to

entries

4. Return

entries

export

1. Let

entries

be a new empty

2. Let

names

3. For each element

name

names

, do

a. Append the

{ [[ModuleRequest]]:

null

, [[ImportName]]:

null

, [[LocalName]]:

name

[[ExportName]]:

name

} to

entries

4. Return

entries

export

default

1. Let

names

2. Let

localName

be the sole element of

names

whose sole element is the

null

, [[ImportName]]:

null

[[LocalName]]:

localName

, [[ExportName]]:

"default"

export

default

1. Let

names

2. Let

localName

be the sole element of

names

whose sole element is the

null

, [[ImportName]]:

null

[[LocalName]]:

localName

, [[ExportName]]:

"default"

458

export

default

;

1. Let

entry

{ [[ModuleRequest]]:

null

, [[ImportName]]:

null

, [[LocalName]]:

"*default*"

, [[ExportName]]:

"default"

2. Return a

whose sole element is

entry

NOTE

With parameter

module

1. Let

entry

{ [[ModuleRequest]]:

module

, [[ImportName]]:

"*"

, [[LocalName]]:

null

[[ExportName]]:

null

2. Return a

whose sole element is

entry

1. Let

exportName

be the

2. Let

entry

{ [[ModuleRequest]]:

module

, [[ImportName]]:

"*"

, [[LocalName]]:

null

[[ExportName]]:

exportName

whose sole element is

entry

{

}

1. Return a new empty

1. Let

specs

be the

with argument

module

2. Append to

specs

the elements of the

with argument

module

3. Return

specs

1. Let

sourceName

be the

2. If

module

null

, then

a. Let

localName

sourceName

b. Let

importName

null

3. Else,

a. Let

localName

null

b. Let

importName

sourceName

4. Return a

whose sole element is the

module

, [[ImportName]]:

importName

, [[LocalName]]:

localName

, [[ExportName]]:

sourceName

1. Let

sourceName

be the

of the first

"*default*"

is used within this specification as a synthetic name for anonymous default export

values.

16.2.3.5 Static Semantics: ExportEntriesForModule

459

2. Let

exportName

be the

of the second

3. If

module

null

, then

a. Let

localName

sourceName

b. Let

importName

null

4. Else,

a. Let

localName

null

b. Let

importName

sourceName

5. Return a

whose sole element is the

module

, [[ImportName]]:

importName

, [[LocalName]]:

localName

, [[ExportName]]:

exportName

{

}

1. Return a new empty

1. Let

names

ReferencedBindings

2. Append to

names

the elements of the

ReferencedBindings

3. Return

names

1. Return a

whose sole element is the first

whose sole element is the

1. Return a

export

;

export

;

1. Return

(

empty

export

1. Return the result of evaluating

export

1. Return the result of evaluating

export

default

1. Return the result of evaluating

export

default

BindingClassDeclarationEvaluation

1. Let

value

be ?

2. Let

className

be the sole element of

16.2.3.6 Static Semantics: ReferencedBindings

16.2.3.7 Runtime Semantics: Evaluation

460

3. If

className

"*default*"

, then

a. Let

env

be the

's LexicalEnvironment.

b. Perform ?

InitializeBoundName

(

"*default*"

value

env

4. Return

(

empty

export

default

IsAnonymousFunctionDefinition

;

1. If

) is

true

, then

a. Let

value

be ?

NamedEvaluation

with argument

"default"

2. Else,

a. Let

rhs

be the result of evaluating

b. Let

value

be ?

GetValue

(

rhs

3. Let

env

be the

's LexicalEnvironment.

4. Perform ?

InitializeBoundName

(

"*default*"

value

env

5. Return

(

empty

An implementation must report most errors at the time the relevant ECMAScript language construct is evaluated. An

early error

is an error that can be detected and reported prior to the evaluation of any construct in the

containing

the error. The presence of an

early error

prevents the evaluation of the construct. An implementation must report early

errors in a

as part of parsing that

ParseScript

. Early errors in a

are reported at the point when

the

would be evaluated and the

is never initialized. Early errors in

eval

code are reported at the time

eval

is called and prevent evaluation of the

eval

code. All errors that are not early errors are runtime errors.

An implementation must report as an

early error

any occurrence of a condition that is listed in a “Static Semantics:

Early Errors” subclause of this specification.

An implementation shall not treat other kinds of errors as early errors even if the compiler can prove that a construct
cannot execute without error under any circumstances. An implementation may issue an early warning in such a case,
but it should not report the error until the relevant construct is actually executed.

An implementation shall report all errors as specified, except for the following:

Except as restricted in

17.1

, a

or implementation may extend

syntax,

expression literal, or using the Function or RegExp

syntax, and regular

expression pattern or flag syntax. To permit this, all operations (such as calling

eval

, using a regular

) that are allowed to throw

SyntaxError

are

permitted to exhibit

behaviour instead of throwing

SyntaxError

when they encounter a

host-

defined

extension to the script syntax or regular expression pattern or flag syntax.

Except as restricted in

17.1

, a

or implementation may provide additional types, values, objects, properties,

and functions beyond those described in this specification. This may cause constructs (such as looking up a
variable in the global scope) to have

AsyncGeneratorDeclaration

behaviour instead of throwing an error (such as

ReferenceError

An implementation must not extend this specification in the following ways:

17 Error Handling and Language Extensions

17.1 Forbidden Extensions

461

ECMAScript function objects defined using syntactic constructors in

strict mode code

must not be created with

own properties named

"caller"

"arguments"

. Such own properties also must not be created for function

objects defined using an

ArrowFunction

MethodDefinition

GeneratorDeclaration

GeneratorExpression

AsyncGeneratorExpression

AsyncFunctionDeclaration

ClassExpression

AsyncFunctionExpression

, or

AsyncArrowFunction

regardless of whether the definition is contained in

strict

mode code

. Built-in functions, strict functions created using the Function

created using the Generator

, generator functions

, async functions created using the AsyncFunction

, and

functions created using the

bind

method also must not be created with such own properties.

If an implementation extends any

, the function that is the value of the property's [[Get]] attribute must never return a

with an own property named

"caller"

the value of that

property, as observed using [[Get]] or [[GetOwnProperty]], must not be a

strict function

object. If it is an

accessor property

strict

function

when called.

Neither mapped nor unmapped arguments objects may be created with an own property named

"caller"

The behaviour of built-in methods which are specified in ECMA-402, such as those named

toLocaleString

, must not be extended except as specified in ECMA-402.

The RegExp pattern grammars in

22.2.1

and

B.1.4

must not be extended to recognize any of the source

characters A-Z or a-z as

IdentityEscape

[+U]

when the

[U]

grammar parameter is present.

The Syntactic Grammar must not be extended in any manner that allows the token

to immediately follow

source text that matches the

BindingIdentifier

nonterminal symbol.

When processing

strict mode code

, the syntax of

NumericLiteral

must not be extended to include

LegacyOctalIntegerLiteral

and the syntax of

DecimalIntegerLiteral

must not be extended to include

NonOctalDecimalIntegerLiteral

as described in

B.1.1

TemplateCharacter

must not be extended to include

LegacyOctalEscapeSequence

NonOctalDecimalEscapeSequence

as defined in

B.1.2

When processing

strict mode code

, the extensions defined in

supported.
When parsing for the

goal symbol

, the lexical grammar extensions defined in

B.1.3

must not be

supported.

ImportCall

must not be extended.

There are certain built-in objects available whenever an ECMAScript

begins execution. One, the

global object

, is part of the global environment of the executing program. Others are accessible as initial properties of

the

global object

or indirectly as properties of accessible built-in objects.

Unless specified otherwise, a built-in object that is callable as a function is a built-in

with the

characteristics described in

10.3

. Unless specified otherwise, the [[Extensible]] internal slot of a built-in object initially

has the value

true

. Every built-in

has a [[Realm]] internal slot whose value is the

Realm Record

of the

realm

for which the object was initially created.

Many built-in objects are functions: they can be invoked with arguments. Some of them furthermore are constructors:
they are functions intended for use with the

new

operator. For each built-in function, this specification describes the

arguments required by that function and the properties of that

specification furthermore describes properties of the prototype object of that

and properties of specific

object instances returned by a

new

expression that invokes that

Unless otherwise specified in the description of a particular function, if a built-in function or

18 ECMAScript Standard Built-in Objects

462

is given

fewer arguments than the function is specified to require, the function or

Unless otherwise specified in the description of a particular function, if a built-in function or

shall behave exactly as if it had

been given sufficient additional arguments, each such argument being the

undefined

value. Such missing arguments

are considered to be “not present” and may be identified in that manner by specification algorithms. In the description
of a particular function, the terms “

this

value” and “NewTarget” have the meanings given in

10.3

Unless otherwise specified every built-in function and every built-in

described is

given more arguments than the function is specified to allow, the extra arguments are evaluated by the call and then
ignored by the function. However, an implementation may define implementation specific behaviour relating to such
arguments as long as the behaviour is not the throwing of a

TypeError

exception that is predicated simply on the

presence of an extra argument.

NOTE 1

Function prototype object

has the

which is the initial value of the expression

Function.prototype

(

20.2.3

), as the value of its [[Prototype]] internal

slot.

Unless otherwise specified every built-in prototype object has the

Object prototype object

, which is the initial value of

), as the value of its [[Prototype]] internal slot, except the

Object

prototype object

itself.

Built-in function objects that are not identified as constructors do not implement the [[Construct]] internal method
unless otherwise specified in the description of a particular function.

Each built-in function defined in this specification is created by calling the

CreateBuiltinFunction

abstract operation

10.3.3

). The values of the

length

and

name

parameters are the initial values of the

"length"

and

"name"

properties as

discussed below. The values of the

prefix

parameter are similarly discussed below.

Every built-in

, including constructors, has a

"length"

property whose value is a non-negative

integral

Number

. Unless otherwise specified, this value is equal to the number of required parameters shown in the subclause

headings for the function description. Optional parameters and rest parameters are not included in the parameter
count.

NOTE 2

Unless otherwise specified, the

"length"

property of a built-in

has the attributes { [[Writable]]:

false

[[Enumerable]]:

false

, [[Configurable]]:

true

Every built-in

string used to access the function. Functions

, including constructors, has a

"name"

property whose value is a String. Unless

otherwise specified, this value is the name that is given to the function in this specification. Functions that are
identified as anonymous functions use the empty String as the value of the

"name"

property. For functions that are

specified as properties of objects, the name value is the

property name

that are specified as get or set accessor functions of built-in properties have

"get"

"set"

(respectively) passed to the

prefix

parameter when calling

CreateBuiltinFunction

Implementations that add additional capabilities to the set of built-in functions are encouraged to
do so by adding new functions rather than adding new parameters to existing functions.

For example, the

that is the initial value of the

is described under the subclause heading «Array.prototype.map (callbackFn [ ,

thisArg])» which shows the two named arguments callbackFn and thisArg, the latter being
optional; therefore the value of the

"length"

property of that