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

does not have a [[Construct]] internal method; it cannot be used as a

constructor

with the

new

operator.

does not have a [[Call]] internal method; it cannot be invoked as a function.
has a [[Prototype]] internal slot whose value is

host-defined

may have

host

defined properties in addition to the properties defined in this specification. This may include a

property whose value is the global object itself.

The initial value of the

"globalThis"

realm

.[[GlobalEnv]].

[[GlobalThisValue]].

This property has the attributes { [[Writable]]:

true

, [[Enumerable]]:

false

, [[Configurable]]:

true

The value of

Infinity

∞

𝔽

(see

6.1.6.1

). This property has the attributes { [[Writable]]:

false

, [[Enumerable]]:

false

, [[Configurable]]:

false

The value of

NaN

NaN

(see

6.1.6.1

). This property has the attributes { [[Writable]]:

false

, [[Enumerable]]:

false

[[Configurable]]:

false

19 The Global Object

19.1 Value Properties of the Global Object

19.1.1 globalThis

19.1.2 Infinity

19.1.3 NaN

464

The value of

undefined

undefined

(see

6.1.1

). This property has the attributes { [[Writable]]:

false

[[Enumerable]]:

false

, [[Configurable]]:

false

The

eval

function is the

%eval%

intrinsic object. When the

eval

function is called with one argument

, the

following steps are taken:

: The

has at least two elements.

2. Let

callerContext

be the second to top element of the

3. Let

callerRealm

callerContext

Realm

4. Return ?

PerformEval

callerRealm

false

The abstract operation PerformEval takes arguments

callerRealm

strictCaller

, and

direct

. It performs the following

steps when called:

HostEnsureCanCompileStrings

: If

direct

false

, then

strictCaller

is also

false

2. If

Type

(

) is not String, return

3. Let

evalRealm

the current Realm Record

4. Perform ?

(

callerRealm

evalRealm

5. Let

inFunction

false

6. Let

inMethod

false

7. Let

inDerivedConstructor

false

8. If

direct

true

, then

a. Let

thisEnvRec

be !

GetThisEnvironment

().

b. If

thisEnvRec

is a

function Environment Record

, then

i. Let

thisEnvRec

.[[FunctionObject]].

ii. Set

inFunction

true

iii. Set

inMethod

thisEnvRec

.HasSuperBinding().

iv. If

.[[ConstructorKind]] is

derived

, set

inDerivedConstructor

true

9. Perform the following substeps in an

implementation-defined

order, possibly interleaving parsing and error

detection:

a. Let

script

b. If

script

is a

of errors, throw a

SyntaxError

exception.

c. If

script

ScriptBody

false

, return

undefined

d. Let

body

ScriptBody

script

e. If

inFunction

false

, and

body

NewTarget

, throw a

SyntaxError

exception.

f. If

inMethod

false

, and

body

SuperProperty

, throw a

SyntaxError

exception.

g. If

inDerivedConstructor

false

, and

body

running execution context

SuperCall

, throw a

SyntaxError

exception.

10. If

strictCaller

true

, let

strictEval

true

11. Else, let

strictEval

IsStrict

script

19.1.4 undefined

19.2 Function Properties of the Global Object

19.2.1 eval (

)

19.2.1.1 PerformEval (

callerRealm

strictCaller

direct

)

465

12. Let

runningContext

be the

13. NOTE: If

direct

true

runningContext

will be the

that performed the

direct eval

. If

direct

false

runningContext

will be the

NewDeclarativeEnvironment

for the invocation of the

eval

function.

14. If

direct

true

, then

a. Let

lexEnv

(

runningContext

's LexicalEnvironment).

b. Let

varEnv

runningContext

's VariableEnvironment.

15. Else,

a. Let

lexEnv

NewDeclarativeEnvironment

(

evalRealm

.[[GlobalEnv]]).

b. Let

varEnv

evalRealm

.[[GlobalEnv]].

16. If

strictEval

true

, set

varEnv

lexEnv

17. If

runningContext

is not already suspended, suspend

runningContext

18. Let

evalContext

be a new ECMAScript code

19. Set

evalContext

's Function to

null

20. Set

evalContext

Realm

evalRealm

21. Set

evalContext

's ScriptOrModule to

runningContext

's ScriptOrModule.

22. Set

evalContext

's VariableEnvironment to

varEnv

23. Set

evalContext

's LexicalEnvironment to

lexEnv

24. Push

evalContext

onto the

running execution context

;

evalContext

is now the

25. Let

result

EvalDeclarationInstantiation

(

body

varEnv

lexEnv

strictEval

26. If

result

.[[Type]] is

normal

, then

a. Set

result

to the result of evaluating

body

27. If

result

.[[Type]] is

normal

and

result

.[[Value]] is

empty

, then

a. Set

result

NormalCompletion

undefined

28. Suspend

evalContext

and remove it from the

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

running execution context

as the

30. Return

Completion

(

result

NOTE

The

host-defined

abstract operation HostEnsureCanCompileStrings takes arguments

callerRealm

calleeRealm

). It allows

environments to block certain ECMAScript functions which allow

developers to compile strings into ECMAScript code.

An implementation of HostEnsureCanCompileStrings may complete normally or abruptly. Any abrupt completions
will be propagated to its callers. The default implementation of HostEnsureCanCompileStrings is to unconditionally
return an empty normal completion.

The abstract operation EvalDeclarationInstantiation takes arguments

body

varEnv

lexEnv

, and

strict

. It performs the

The eval code cannot instantiate variable or function bindings in the variable environment of the
calling context that invoked the eval if the calling context is evaluating formal parameter
initializers or if either the code of the calling context or the eval code is

strict mode code

. Instead

such bindings are instantiated in a new VariableEnvironment that is only accessible to the eval
code. Bindings introduced by

let

const

, or

class

declarations are always instantiated in a

new LexicalEnvironment.

19.2.1.2 HostEnsureCanCompileStrings (

callerRealm

calleeRealm

)

19.2.1.3 EvalDeclarationInstantiation (

body

varEnv

lexEnv

strict

)

466

following steps when called:

1. Let

varNames

be the

VarDeclaredNames

body

2. Let

varDeclarations

VarScopedDeclarations

body

3. If

strict

false

, then

a. If

varEnv

is a

i. For each element

name

varNames

, do

1. If

varEnv

.HasLexicalDeclaration(

name

) is

true

, throw a

SyntaxError

exception.

2. NOTE:

eval

will not create a global var declaration that would be shadowed by a global

lexical declaration.

b. Let

thisEnv

lexEnv

object Environment Record

: The following loop will terminate.

d. Repeat, while

thisEnv

is not the same as

varEnv

i. If

thisEnv

is not an

defines alternate semantics for the above step.

1. NOTE: The environment of with statements cannot contain any lexical declaration so it

doesn't need to be checked for var/let hoisting conflicts.

2. For each element

name

varNames

, do

a. If

thisEnv

.HasBinding(

name

) is

true

, then

i. Throw a

SyntaxError

exception.

ii. NOTE: Annex

B.3.5

b. NOTE: A

direct eval

will not hoist var declaration over a like-named lexical

declaration.

ii. Set

thisEnv

.[[OuterEnv]].

4. Let

functionsToInitialize

be a new empty

5. Let

declaredFunctionNames

be a new empty

6. For each element

varDeclarations

, in reverse

AsyncFunctionDeclaration

order, do

a. If

is neither a

VariableDeclaration

FunctionDeclaration

, a

GeneratorDeclaration

, an

, or an

AsyncGeneratorDeclaration

ii. NOTE: If there are multiple function declarations for the same name, the last declaration is used.

iii. Let

be the sole element of the

iv. If

is not an element of

declaredFunctionNames

, then

1. If

varEnv

is a

a. Let

fnDefinable

be ?

varEnv

.CanDeclareGlobalFunction(

b. If

fnDefinable

false

, throw a

TypeError

exception.

2. Append

declaredFunctionNames

3. Insert

as the first element of

functionsToInitialize

7. NOTE: Annex

B.3.3.3

adds additional steps at this point.

8. Let

declaredVarNames

be a new empty

9. For each element

varDeclarations

, do

a. If

is a

VariableDeclaration

i. For each String

of the

, do

1. If

is not an element of

declaredFunctionNames

, then

a. If

varEnv

is a

i. Let

vnDefinable

be ?

varEnv

.CanDeclareGlobalVar(

ii. If

vnDefinable

false

, throw a

TypeError

exception.

b. If

is not an element of

declaredVarNames

, then

i. Append

declaredVarNames

467

10. NOTE: No abnormal terminations occur after this algorithm step unless

varEnv

is a

LexicallyScopedDeclarations

and the

global object

is a

Proxy exotic object

11. Let

lexDeclarations

be the

body

12. For each element

lexDeclarations

, do

a. NOTE: Lexically declared names are only instantiated here but not initialized.

b. For each element

of the

be the sole element of the

, do

i. If

IsConstantDeclaration

true

, then

1. Perform ?

lexEnv

.CreateImmutableBinding(

true

ii. Else,

1. Perform ?

lexEnv

.CreateMutableBinding(

false

13. For each

Parse Node

functionsToInitialize

, do

a. Let

InstantiateFunctionObject

b. Let

with argument

lexEnv

c. If

varEnv

is a

i. Perform ?

varEnv

.CreateGlobalFunctionBinding(

true

d. Else,

i. Let

bindingExists

varEnv

.HasBinding(

ii. If

bindingExists

false

, then

1. Let

status

be !

varEnv

.CreateMutableBinding(

true

status

is not an

abrupt completion

because of validation preceding step

3. Perform !

varEnv

.InitializeBinding(

iii. Else,

1. Perform !

varEnv

.SetMutableBinding(

false

14. For each String

declaredVarNames

, do

a. If

varEnv

is a

i. Perform ?

varEnv

.CreateGlobalVarBinding(

true

b. Else,

i. Let

bindingExists

varEnv

.HasBinding(

ii. If

bindingExists

false

, then

1. Let

status

be !

varEnv

.CreateMutableBinding(

true

status

is not an

abrupt completion

because of validation preceding step

3. Perform !

varEnv

.InitializeBinding(

undefined

15. Return

NormalCompletion

(

empty

NOTE

The

isFinite

function is the

%isFinite%

intrinsic object. When the

isFinite

function is called with one

argument

number

, the following steps are taken:

1. Let

num

An alternative version of this algorithm is described in

ToNumber

(

number

2. If

num

NaN

∞

𝔽

, or

∞

𝔽

, return

false

3. Otherwise, return

true

B.3.5

19.2.2 isFinite (

number

)

19.2.3 isNaN (

number

)

468

The

isNaN

function is the

%isNaN%

intrinsic object. When the

isNaN

function is called with one argument

number

the following steps are taken:

1. Let

num

ToNumber

(

number

2. If

num

NaN

, return

true

3. Otherwise, return

false

NOTE

The

parseFloat

function produces a

Number value

dictated by interpretation of the contents of the

string

argument as a decimal literal.

The

parseFloat

function is the

%parseFloat%

intrinsic object. When the

parseFloat

function is called with one

argument

string

, the following steps are taken:

1. Let

inputString

string

2. Let

trimmedString

be !

TrimString

inputString

start

3. If neither

trimmedString

nor any prefix of

trimmedString

satisfies the syntax of a

StrDecimalLiteral

(see

7.1.4.1

return

NaN

4. Let

numberString

be the longest prefix of

trimmedString

, which might be

trimmedString

itself, that satisfies the

syntax of a

StrDecimalLiteral

5. Let

mathFloat

be MV of

numberString

6. If

mathFloat

= 0, then

a. If the first code unit of

trimmedString

is the code unit 0x002D (HYPHEN-MINUS), return

-0

𝔽

b. Return

𝔽

7. Return

mathFloat

NOTE

The

parseInt

function produces an

integral Number

dictated by interpretation of the contents of the

string

argument according to the specified

radix

. Leading white space in

string

is ignored. If

radix

undefined

or 0, it is

assumed to be 10 except when the number begins with the code unit pairs

, in which case a radix of 16 is

assumed. If

radix

is 16, the number may also optionally begin with the code unit pairs

The

parseInt

function is the

%parseInt%

intrinsic object. When the

parseInt

function is called, the following

steps are taken:

1. Let

inputString

string

2. Let

be !

TrimString

(

inputString

start

3. Let

sign

be 1.

A reliable way for ECMAScript code to test if a value

is a

NaN

is an expression of the form

X !== X

. The result will be

true

if and only if

is a

NaN

parseFloat

may interpret only a leading portion of

string

as a

Number value

; it ignores any

code units that cannot be interpreted as part of the notation of a decimal literal, and no indication
is given that any such code units were ignored.

19.2.4 parseFloat (

string

)

19.2.5 parseInt (

string

radix

)

469

4. If

is not empty and the first code unit of

is the code unit 0x002D (HYPHEN-MINUS), set

sign

to -1.

5. If

is not empty and the first code unit of

is the code unit 0x002B (PLUS SIGN) or the code unit 0x002D

(HYPHEN-MINUS), remove the first code unit from

6. Let

ToInt32

(

radix

)).

7. Let

stripPrefix

true

8. If

≠

0, then

a. If

< 2 or

> 36, return

NaN

b. If

≠

16, set

stripPrefix

false

9. Else,

a. Set

to 10.

10. If

stripPrefix

true

, then

a. If the length of

is at least 2 and the first two code units of

are either

"0x"

"0X"

, then

i. Remove the first two code units from

ii. Set

to 16.

11. If

contains a code unit that is not a radix-

digit, let

end

be the index within

of the first such code unit;

otherwise, let

end

be the length of

12. Let

be the

substring

from 0 to

end

13. If

is empty, return

NaN

14. Let

mathInt

be the

implementation-approximated

value that is represented by

in radix-

notation, using the letters

and

for

digits with values 10 through 35. (However, if

is 10 and

contains more than 20 significant digits, every

significant digit after the 20th may be replaced by a 0 digit, at the option of the implementation; and if

is not

2, 4, 8, 10, 16, or 32, then

mathInt

may be an

value representing the

value

that is represented by

in radix-

notation.)

15. If

mathInt

= 0, then

a. If

sign

= -1, return

-0

𝔽

b. Return

𝔽

16. Return

sign

mathInt

NOTE

Uniform Resource Identifiers, or URIs, are Strings that identify resources (e.g. web pages or files) and transport
protocols by which to access them (e.g. HTTP or FTP) on the Internet. The ECMAScript language itself does not
provide any support for using URIs except for functions that encode and decode URIs as described in

NOTE

A URI is composed of a sequence of components separated by component separators. The general form is:

parseInt

may interpret only a leading portion of

string

as an

value; it ignores any code

units that cannot be interpreted as part of the notation of an

uriReserved
uriUnescaped
uriEscaped

, and no indication is given

that any such code units were ignored.

Many implementations of ECMAScript provide additional functions and methods that
manipulate web pages; these functions are beyond the scope of this standard.

19.2.6 URI Handling Functions

19.2.6.1 URI Syntax and Semantics

470

Scheme

First

Second

;;

Third

Fourth

where the italicized names represent components and “

”, “

;;

” and “

” are reserved for use as separators. The

encodeURI

and

decodeURI

functions are intended to work with complete URIs; they assume that any reserved

code units in the URI are intended to have special meaning and so are not encoded. The

encodeURIComponent

and

decodeURIComponent

functions are intended to work with the individual component parts of a URI; they

assume that any reserved code units represent text and so must be encoded so that they are not interpreted as
reserved code units when the component is part of a complete URI.

The following lexical grammar specifies the form of encoded URIs.

:::

:::

opt

:::

uriReserved

:::

one of

;

uriUnescaped

:::

uriAlpha
DecimalDigit
uriMark

uriEscaped

:::

HexDigit

uriAlpha

:::

one of

uriMark

:::

one of

(

)

NOTE

When a code unit to be included in a URI is not listed above or is not intended to have the special meaning sometimes
given to the reserved code units, that code unit must be encoded. The code unit is transformed into its UTF-8
encoding, with

surrogate pairs

first converted from UTF-16 to the corresponding code point value. (Note that for code

The above syntax is based upon RFC 2396 and does not reflect changes introduced by the more
recent RFC 3986.

Syntax

Runtime Semantics

471

units in the range [0, 127] this results in a single octet with the same value.) The resulting sequence of octets is then
transformed into a String with each octet represented by an escape sequence of the form

"%xx"

The abstract operation Encode takes arguments

string

(a String) and

unescapedSet

(a String). It performs URI encoding

and escaping. It performs the following steps when called:

1. Let

strLen

be the number of code units in

string

2. Let

be the empty String.

3. Let

be 0.

4. Repeat,

a. If

strLen

, return

b. Let

be the code unit at index

within

string

c. If

is in

unescapedSet

, then

i. Set

+ 1.

ii. Set

to the

string-concatenation

and

d. Else,

i. Let

be !

CodePointAt

string

ii. If

.[[IsUnpairedSurrogate]] is

true

, throw a

URIError

exception.

iii. Set

.[[CodeUnitCount]].

iv. Let

Octets

of octets resulting by applying the UTF-8 transformation to

[[CodePoint]].

v. For each element

octet

Octets

, do

1. Set

to the

string-concatenation

of:

"%"

the String representation of

octet

, formatted as a two-digit uppercase hexadecimal

number, padded to the left with a zero if necessary

The abstract operation Decode takes arguments

string

(a String) and

reservedSet

(a String). It performs URI unescaping

and decoding. It performs the following steps when called:

1. Let

strLen

be the length of

string

2. Let

be the empty String.

3. Let

be 0.

4. Repeat,

a. If

strLen

, return

b. Let

be the code unit at index

within

string

c. If

is not the code unit 0x0025 (PERCENT SIGN), then

i. Let

be the String value containing only the code unit

d. Else,

i. Let

start

ii. If

+ 2

≥

strLen

, throw a

URIError

exception.

iii. If the code units at index (

+ 1) and (

+ 2) within

string

do not represent hexadecimal digits,

throw a

URIError

exception.

iv. Let

be the 8-bit value represented by the two hexadecimal digits at index (

+ 1) and (

+ 2).

19.2.6.1.1 Encode (

string

unescapedSet

)

19.2.6.1.2 Decode (

string

reservedSet

)

472

v. Set

+ 2.

vi. Let

be the number of leading 1 bits in

vii. If

= 0, then

1. Let

be the code unit whose value is

2. If

is not in

reservedSet

, then

a. Let

be the String value containing only the code unit

3. Else,

a. Let

substring

string

from

start

+ 1.

viii. Else,

1. If

= 1 or

> 4, throw a

URIError

exception.

2. If

+ (3

(

- 1))

≥

strLen

, throw a

URIError

exception.

3. Let

Octets

be a

whose sole element is

4. Let

be 1.

5. Repeat, while

a. Set

+ 1.

b. If the code unit at index

within

string

is not the code unit 0x0025 (PERCENT

SIGN), throw a

URIError

exception.

c. If the code units at index (

+ 1) and (

+ 2) within

string

do not represent

hexadecimal digits, throw a

URIError

exception.

d. Let

be the 8-bit value represented by the two hexadecimal digits at index (

+ 1)

and (

+ 2).

e. Set

+ 2.

f. Append

Octets

g. Set

+ 1.

: The length of

Octets

7. If

Octets

does not contain a valid UTF-8 encoding of a Unicode code point, throw a

URIError

exception.

8. Let

be the code point obtained by applying the UTF-8 transformation to

Octets

, that is,

from a

of octets into a 21-bit value.

9. Let

e. Set

and

f. Set

+ 1.

NOTE

This syntax of Uniform Resource Identifiers is based upon RFC 2396 and does not reflect the
more recent RFC 3986 which replaces RFC 2396. A formal description and implementation of
UTF-8 is given in RFC 3629.

In UTF-8, characters are encoded using sequences of 1 to 6 octets. The only octet of a sequence of
one has the higher-order bit set to 0, the remaining 7 bits being used to encode the character
value. In a sequence of n octets, n > 1, the initial octet has the n higher-order bits set to 1,
followed by a bit set to 0. The remaining bits of that octet contain bits from the value of the
character to be encoded. The following octets all have the higher-order bit set to 1 and the
following bit set to 0, leaving 6 bits in each to contain bits from the character to be encoded. The
possible UTF-8 encodings of ECMAScript characters are specified in

Table 49

473

The

decodeURI

function computes a new version of a URI in which each escape sequence and UTF-8 encoding of

the sort that might be introduced by the

encodeURI

function is replaced with the UTF-16 encoding of the code

points that it represents. Escape sequences that could not have been introduced by

encodeURI

are not replaced.

Table 49 (Informative): UTF-8 Encodings

Code Unit

Value

Representation

Octet

0x0000 -

0x007F

00000000

zzzzzzz

0x0080 -

0x07FF

00000

yyy

yyzzzzzz

110

yyyyy

zzzzzz

0x0800 -

0xD7FF

xxxxyyyy

yyzzzzzz

1110

xxxx

yyyyyy

zzzzzz

0xD800 -

0xDBFF

followed by

0xDC00 -

0xDFFF

110110

vvwwwwxx

followed by

110111

yyzzzzzz

11110

uuu

uuwwww

xxyyyy

zzzzzz

0xD800 -

0xDBFF

not followed by

0xDC00 -

0xDFFF

causes

URIError

0xDC00 -

0xDFFF

causes

URIError

0xE000 -

0xFFFF

xxxxyyyy

yyzzzzzz

1110

xxxx

yyyyyy

zzzzzz

Where

uuuuu

vvvv

+ 1

to account for the addition of 0x10000 as in section 3.8 of the Unicode Standard (Surrogates).

The above transformation combines each

surrogate pair

(for which code unit values in the

inclusive range 0xD800 to 0xDFFF are reserved) into a UTF-32 representation and encodes the
resulting 21-bit value into UTF-8. Decoding reconstructs the

surrogate pair

RFC 3629 prohibits the decoding of invalid UTF-8 octet sequences. For example, the invalid
sequence C0 80 must not decode into the code unit 0x0000. Implementations of the Decode
algorithm are required to throw a

URIError

when encountering such invalid sequences.

19.2.6.2 decodeURI (

encodedURI

)

474

The

decodeURI

function is the

%decodeURI%

intrinsic object. When the

decodeURI

function is called with one

argument

encodedURI

, the following steps are taken:

1. Let

uriString

be ?

be a String containing one instance of each code unit valid in

encodedURI

2. Let

reservedURISet

uriReserved

plus

"#"

Decode

(

uriString

reservedURISet

NOTE

The

decodeURIComponent

function computes a new version of a URI in which each escape sequence and UTF-8

encoding of the sort that might be introduced by the

encodeURIComponent

function is replaced with the UTF-16

encoding of the code points that it represents.

The

decodeURIComponent

function is the

%decodeURIComponent%

intrinsic object. When the

decodeURIComponent

function is called with one argument

encodedURIComponent

, the following steps are taken:

1. Let

componentString

encodedURIComponent

2. Let

reservedURIComponentSet

be the empty String.

function computes a new version of a UTF-16 encoded (

Decode

(

componentString

reservedURIComponentSet

The

encodeURI

6.1.4

) URI in which each instance of certain

code points is replaced by one, two, three, or four escape sequences representing the UTF-8 encoding of the code
points.

The

encodeURI

function is the

%encodeURI%

intrinsic object. When the

encodeURI

function is called with one

argument

uri

, the following steps are taken:

1. Let

uriString

be ?

uri

2. Let

unescapedURISet

be a String containing one instance of each code unit valid in

uriReserved

and

uriUnescaped

plus

"#"

function computes a new version of a UTF-16 encoded (

Encode

(

uriString

unescapedURISet

NOTE

The

encodeURIComponent

6.1.4

) URI in which each

instance of certain code points is replaced by one, two, three, or four escape sequences representing the UTF-8
encoding of the code point.

The

encodeURIComponent

function is the

%encodeURIComponent%

intrinsic object. When the

encodeURIComponent

function is called with one argument

uriComponent

, the following steps are taken:

The code point

is not decoded from escape sequences even though it is not a reserved URI code

point.

The code point

is not encoded to an escape sequence even though it is not a reserved or

unescaped URI code point.

19.2.6.3 decodeURIComponent (

encodedURIComponent

)

19.2.6.4 encodeURI (

uri

)

19.2.6.5 encodeURIComponent (

uriComponent

)

475

1. Let

componentString

uriComponent

2. Let

unescapedURIComponentSet

be a String containing one instance of each code unit valid in

uriUnescaped