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

flags. An implementation may interpret use of this method as an assertion that the resulting
RegExp object will be used multiple times and hence is a candidate for extra optimization.

The

List

returned by

PropertyNameList

does not include string literal property names defined as

using a

ComputedPropertyName

B.2.5 Additional Properties of the RegExp.prototype Object

B.2.5.1 RegExp.prototype.compile (

pattern

flags

)

B.3 Other Additional Features

B.3.1 __proto__ Property Names in Object Initializers

858

PropertyDefinition

PropertyName

AssignmentExpression

1. Let

propKey

be the result of evaluating

PropertyName

ReturnIfAbrupt

(

propKey

3. If

propKey

is the String value

"__proto__"

and if

IsComputedPropertyKey

(

PropertyName

) is

false

, then

a. Let

isProtoSetter

true

4. Else,

a. Let

isProtoSetter

false

5. If

IsAnonymousFunctionDefinition

(

AssignmentExpression

) is

true

and

isProtoSetter

false

, then

a. Let

propValue

be ?

NamedEvaluation

AssignmentExpression

with argument

propKey

6. Else,

a. Let

exprValueRef

be the result of evaluating

AssignmentExpression

b. Let

propValue

be ?

GetValue

(

exprValueRef

7. If

isProtoSetter

true

, then

a. If

Type

(

propValue

) is either Object or Null, then

i. Return

object

.[[SetPrototypeOf]](

propValue

b. Return

NormalCompletion

(

empty

Assert

enumerable

true

Assert

object

is an ordinary, extensible object with no non-configurable properties.

10. Return !

CreateDataPropertyOrThrow

(

object

propKey

propValue

Prior to ECMAScript 2015, the specification of

LabelledStatement

did not allow for the association of a statement label

with a

FunctionDeclaration

. However, a labelled

FunctionDeclaration

was an allowable extension for

non-strict code

and

most browser-hosted ECMAScript implementations supported that extension. In ECMAScript 2015 and later, the
grammar production for

LabelledStatement

permits use of

FunctionDeclaration

includes an

Early Error rule that produces a Syntax Error if that occurs. That rule is modified with the addition of the highlighted
text:

LabelledItem

FunctionDeclaration

It is a Syntax Error if any strict mode source code matches this rule.

NOTE

Prior to ECMAScript 2015, the ECMAScript specification did not define the occurrence of a

FunctionDeclaration

as an

. However, support for that form of

FunctionDeclaration

was an allowable

extension and most browser-hosted ECMAScript implementations permitted them. Unfortunately, the semantics of
such declarations differ among those implementations. Because of these semantic differences, existing web
ECMAScript code that uses

Block

level function declarations is only portable among browser implementation if the

usage only depends upon the semantic intersection of all of the browser implementations for such declarations. The
following are the use cases that fall within that intersection semantics:

1. A function is declared and only referenced within a single block

prevent these

statements from containing a labelled

FunctionDeclaration

non-strict code

B.3.2 Labelled Function Declarations

B.3.3 Block-Level Function Declarations Web Legacy Compatibility Semantics

859

One or more

FunctionDeclaration

s whose

BindingIdentifier

is the name

occur within the function code of

an enclosing function

and that declaration is nested within a

Block

No other declaration of

that is not a

var

declaration occurs within the function code of

All occurrences of

as an

IdentifierReference

are within the

StatementList

of the

Block

containing the

declaration of

2. A function is declared and possibly used within a single

Block

but also referenced by an inner function

definition that is not contained within that same

Block

One or more

FunctionDeclaration

s whose

BindingIdentifier

is the name

occur within the function code of

an enclosing function

and that declaration is nested within a

Block

No other declaration of

that is not a

var

declaration occurs within the function code of

There may be occurrences of

as an

IdentifierReference

within the

StatementList

of the

Block

containing the

declaration of

There is at least one occurrence of

as an

IdentifierReference

within another function

that is nested

within

and no other declaration of

shadows the references to

from within

All invocations of

occur after the declaration of

has been evaluated.

3. A function is declared and possibly used within a single block but also referenced within subsequent blocks.

One or more

FunctionDeclaration

whose

BindingIdentifier

is the name

occur within the function code of

an enclosing function

and that declaration is nested within a

Block

No other declaration of

that is not a

var

declaration occurs within the function code of

There may be occurrences of

as an

IdentifierReference

within the

StatementList

of the

Block

containing the

declaration of

There is at least one occurrence of

as an

IdentifierReference

within the function code of

that lexically

follows the

Block

containing the declaration of

The first use case is interoperable with the semantics of

Block

level function declarations provided by ECMAScript

2015. Any pre-existing ECMAScript code that employs that use case will operate using the Block level function
declarations semantics defined by clauses

, and

ECMAScript 2015 interoperability for the second and third use cases requires the following extensions to the clause

semantics.

If an ECMAScript implementation has a mechanism for reporting diagnostic warning messages, a warning should be
produced when code contains a

FunctionDeclaration

for which these compatibility semantics are applied and introduce

observable differences from non-compatibility semantics. For example, if a var binding is not introduced because its
introduction would create an

early error

, a warning message should not be produced.

During

FunctionDeclarationInstantiation

the following steps are performed in place of step

29. If

strict

false

, then

a. For each

FunctionDeclaration

that is directly contained in the

, or

, do

i. Let

StringValue

of the

BindingIdentifier

ii. If replacing the

FunctionDeclaration

with a

VariableStatement

that has

as a

BindingIdentifier

would not produce any Early Errors for

func

and

is not an element of

parameterNames

, then

B.3.3.1 Changes to FunctionDeclarationInstantiation

860

1. NOTE: A var binding for

is only instantiated here if it is neither a VarDeclaredName, the

name of a formal parameter, or another

FunctionDeclaration

2. If

initializedBindings

does not contain

and

is not

"arguments"

, then

a. Perform !

varEnv

.CreateMutableBinding(

false

b. Perform

varEnv

.InitializeBinding(

undefined

c. Append

instantiatedVarNames

3. When the

FunctionDeclaration

is evaluated, perform the following steps in place of the

FunctionDeclaration

Evaluation algorithm provided in

15.2.6

a. Let

fenv

be the

running execution context

's VariableEnvironment.

b. Let

benv

be the

running execution context

's LexicalEnvironment.

c. Let

fobj

be !

benv

.GetBindingValue(

false

d. Perform !

fenv

.SetMutableBinding(

fobj

false

e. Return

NormalCompletion

(

empty

During

GlobalDeclarationInstantiation

the following steps are performed in place of step

13. Let

strict

IsStrict

script

14. If

strict

false

, then

a. Let

declaredFunctionOrVarNames

be a new empty

List

b. Append to

declaredFunctionOrVarNames

the elements of

declaredFunctionNames

c. Append to

declaredFunctionOrVarNames

the elements of

declaredVarNames

d. For each

FunctionDeclaration

that is directly contained in the

, or

Contained within

script

, do

i. Let

StringValue

of the

BindingIdentifier

ii. If replacing the

FunctionDeclaration

with a

VariableStatement

that has

as a

BindingIdentifier

would not produce any Early Errors for

script

, then

1. If

env

.HasLexicalDeclaration(

) is

false

, then

a. Let

fnDefinable

be ?

env

.CanDeclareGlobalVar(

b. If

fnDefinable

true

, then

i. NOTE: A var binding for

is only instantiated here if it is neither a

VarDeclaredName nor the name of another

FunctionDeclaration

ii. If

declaredFunctionOrVarNames

does not contain

, then

i. Perform ?

env

.CreateGlobalVarBinding(

false

ii. Append

declaredFunctionOrVarNames

iii. When the

FunctionDeclaration

is evaluated, perform the following steps in

place of the

FunctionDeclaration

Evaluation algorithm provided in

15.2.6

i. Let

genv

be the

running execution context

's VariableEnvironment.

ii. Let

benv

be the

running execution context

's LexicalEnvironment.

iii. Let

fobj

be !

benv

.GetBindingValue(

false

iv. Perform ?

genv

.SetMutableBinding(

fobj

false

v. Return

NormalCompletion

(

empty

During

EvalDeclarationInstantiation

the following steps are performed in place of step

7. If

strict

false

, then

B.3.3.2 Changes to GlobalDeclarationInstantiation

B.3.3.3 Changes to EvalDeclarationInstantiation

861

a. Let

declaredFunctionOrVarNames

be a new empty

List

b. Append to

declaredFunctionOrVarNames

the elements of

declaredFunctionNames

c. Append to

declaredFunctionOrVarNames

the elements of

declaredVarNames

d. For each

FunctionDeclaration

that is directly contained in the

, or

Contained within

body

, do

i. Let

StringValue

of the

BindingIdentifier

ii. If replacing the

FunctionDeclaration

with a

VariableStatement

that has

as a

BindingIdentifier

would not produce any Early Errors for

body

, then

1. Let

bindingExists

false

2. Let

thisEnv

lexEnv

Assert

: The following loop will terminate.

4. Repeat, while

thisEnv

is not the same as

varEnv

a. If

thisEnv

is not an

object Environment Record

, then

i. If

thisEnv

.HasBinding(

) is

true

, then

i. Let

bindingExists

true

b. Set

thisEnv

.[[OuterEnv]].

5. If

bindingExists

false

and

varEnv

is a

global Environment Record

, then

a. If

varEnv

.HasLexicalDeclaration(

) is

false

, then

i. Let

fnDefinable

be ?

varEnv

.CanDeclareGlobalVar(

b. Else,

i. Let

fnDefinable

false

6. Else,

a. Let

fnDefinable

true

7. If

bindingExists

false

and

fnDefinable

true

, then

a. If

declaredFunctionOrVarNames

does not contain

, then

i. If

varEnv

is a

global Environment Record

, then

i. Perform ?

varEnv

.CreateGlobalVarBinding(

true

ii. Else,

i. Let

bindingExists

varEnv

.HasBinding(

ii. If

bindingExists

false

, then

i. Perform !

varEnv

.CreateMutableBinding(

true

ii. Perform !

varEnv

.InitializeBinding(

undefined

iii. Append

declaredFunctionOrVarNames

b. When the

FunctionDeclaration

is evaluated, perform the following steps in place of

the

FunctionDeclaration

Evaluation algorithm provided in

15.2.6

i. Let

genv

be the

running execution context

's VariableEnvironment.

ii. Let

benv

be the

running execution context

's LexicalEnvironment.

iii. Let

fobj

be !

benv

.GetBindingValue(

false

iv. Perform ?

genv

.SetMutableBinding(

fobj

false

v. Return

NormalCompletion

(

empty

The rules for the following production in

14.2.1

are modified with the addition of the highlighted text:

Block

{

StatementList

}

It is a Syntax Error if the

LexicallyDeclaredNames

StatementList

contains any duplicate entries, unless the

B.3.3.4 Changes to Block Static Semantics: Early Errors

862

source code matching this production is not

strict mode code

and the duplicate entries are only bound by

FunctionDeclarations.
It is a Syntax Error if any element of the

LexicallyDeclaredNames

StatementList

also occurs in the

VarDeclaredNames

StatementList

The rules for the following production in

14.12.1

are modified with the addition of the highlighted text:

SwitchStatement

switch

(

Expression

)

CaseBlock

It is a Syntax Error if the

LexicallyDeclaredNames

CaseBlock

contains any duplicate entries, unless the source

code matching this production is not

strict mode code

and the duplicate entries are only bound by

FunctionDeclarations.
It is a Syntax Error if any element of the

LexicallyDeclaredNames

CaseBlock

also occurs in the

VarDeclaredNames

CaseBlock

During

BlockDeclarationInstantiation

the following steps are performed in place of step

3.a.ii.1

1. If

env

.HasBinding(

) is

false

, then

a. Perform !

env

.CreateMutableBinding(

false

During

BlockDeclarationInstantiation

the following steps are performed in place of step

3.b.iii

iii. If the binding for

env

is an uninitialized binding, then

1. Perform

env

.InitializeBinding(

iv. Else,

Assert

is a

FunctionDeclaration

2. Perform

env

.SetMutableBinding(

false

The following augments the

IfStatement

production in

14.6

IfStatement

[Yield, Await, Return]

(

Expression

[+In, ?Yield, ?Await]

)

FunctionDeclaration

[?Yield, ?Await, ~Default]

else

Statement

[?Yield, ?Await, ?Return]

(

Expression

[+In, ?Yield, ?Await]

)

Statement

[?Yield, ?Await, ?Return]

else

FunctionDeclaration

[?Yield, ?Await, ~Default]

(

Expression

[+In, ?Yield, ?Await]

)

FunctionDeclaration

[?Yield, ?Await, ~Default]

else

FunctionDeclaration

[?Yield, ?Await, ~Default]

(

Expression

[+In, ?Yield, ?Await]

)

FunctionDeclaration

[?Yield, ?Await, ~Default]

[lookahead

≠

else

]

This production only applies when parsing

non-strict code

. Code matching this production is processed as if each

matching occurrence of

FunctionDeclaration

[?Yield, ?Await, ~Default]

was the sole

StatementListItem

of a

BlockStatement

occupying that position in the source code. The semantics of such a synthetic

BlockStatement

includes the web legacy

compatibility semantics specified in

B.3.3

B.3.3.5 Changes to

switch

Statement Static Semantics: Early Errors

B.3.3.6 Changes to BlockDeclarationInstantiation

B.3.4 FunctionDeclarations in IfStatement Statement Clauses

863

The content of subclause

14.15.1

is replaced with the following:

Catch

catch

(

CatchParameter

)

Block

It is a Syntax Error if

BoundNames

CatchParameter

contains any duplicate elements.

It is a Syntax Error if any element of the

BoundNames

CatchParameter

also occurs in the

LexicallyDeclaredNames

Block

It is a Syntax Error if any element of the

NOTE

This modified behaviour also applies to

var

and

function

declarations introduced by

direct eval

calls contained

within the

Block

of a

Catch

clause. This change is accomplished by modifying the algorithm of

19.2.1.3

as follows:

Step

3.d.i.2.a.i

is replaced by:

i. If

thisEnv

is not the

Environment Record

for a

Catch

clause, throw a

SyntaxError

exception.

Step

7.d.ii.4.a.i.i

is replaced by:

i. If

thisEnv

is not the

Environment Record

for a

Catch

clause, let

bindingExists

true

The following augments the

[Yield, Await, Return]

for

(

var

BindingIdentifier

[?Yield, ?Await]

Initializer

[~In, ?Yield, ?Await]

Expression

[+In, ?Yield, ?Await]

)

Statement

[?Yield, ?Await, ?Return]

This production only applies when parsing

non-strict code

The

static semantics

ContainsDuplicateLabels

8.2.1

are augmented with the following:

ForInOfStatement

for

(

var

)

1. Return

ContainsDuplicateLabels

Statement

with argument

labelSet

The

static semantics

ContainsUndefinedBreakTarget

8.2.2

are augmented with the following:

ForInOfStatement

for

(

var

)

1. Return

ContainsUndefinedBreakTarget

Statement

with argument

labelSet

The

static semantics

ContainsUndefinedContinueTarget

8.2.3

are augmented with the following:

var

declarations that bind a name that is also bound by

the

CatchParameter

. At runtime, such bindings are instantiated in the

VariableDeclarationEnvironment. They do not shadow the same-named bindings introduced by
the

CatchParameter

and hence the

Initializer

for such

var

declarations will assign to the

corresponding catch parameter rather than the

var

binding.

B.3.5 VariableStatements in Catch Blocks

B.3.6 Initializers in ForIn Statement Heads

864

ForInOfStatement

for

(

var

)

1. Return

ContainsUndefinedContinueTarget

Statement

with arguments

iterationSet

and « ».

are augmented with the following:

BindingIdentifier

Identifier

yield

await

1. Return

false

are augmented with the following:

ForInOfStatement

for

(

var

)

1. Let

names

be the

BoundNames

BindingIdentifier

2. Append to

names

the elements of the

VarDeclaredNames

Statement

3. Return

names

The

static semantics

VarScopedDeclarations

8.1.7

are augmented with the following:

ForInOfStatement

for

(

var

)

1. Let

declarations

be a

List

whose sole element is

BindingIdentifier

2. Append to

declarations

the elements of the

VarScopedDeclarations

Statement

3. Return

declarations

The

runtime semantics

ForInOfLoopEvaluation

14.7.5.5

are augmented with the following:

ForInOfStatement

for

(

var

)

1. Let

bindingId

StringValue

BindingIdentifier

2. Let

lhs

be ?

ResolveBinding

(

bindingId

3. If

IsAnonymousFunctionDefinition

(

Initializer

) is

true

, then

a. Let

value

NamedEvaluation

Initializer

with argument

bindingId

4. Else,

a. Let

rhs

be the result of evaluating

Initializer

b. Let

value

be ?

GetValue

(

rhs

5. Perform ?

PutValue

(

lhs

value

6. Let

keyResult

be ?

ForIn/OfHeadEvaluation

(« »,

Expression

enumerate

7. Return ?

ForIn/OfBodyEvaluation

(

BindingIdentifier

Statement

keyResult

enumerate

varBinding

labelSet

[[IsHTMLDDA]] internal slot

may exist on

host-defined

objects. Objects with an [[IsHTMLDDA]] internal slot

behave like

undefined

in the

ToBoolean

and

Abstract Equality Comparison

and when used as an

B.3.7 The [[IsHTMLDDA]] Internal Slot

865

NOTE

The result column in

Table 11

for an argument type of Object is replaced with the following algorithm:

1. If

argument

has an

[[IsHTMLDDA]] internal slot

, return

false

2. Return

true

The following steps replace step

of the

Abstract Equality Comparison

algorithm:

1. If

Type

(

) is Object and

has an

[[IsHTMLDDA]] internal slot

and

is either

null

undefined

, return

true

2. If

is either

null

undefined

and

Type

(

) is Object and

has an

[[IsHTMLDDA]] internal slot

, return

true

The following table entry is inserted into

Table 37

immediately preceding the entry for "Object (implements [[Call]])":

Table 83: Additional

typeof

Operator Results

Type of

val

Result

Object (has an

[[IsHTMLDDA]] internal slot

)

"undefined"

The strict mode restriction and exceptions

implements

interface

let

package

private

protected

public

static

, and

yield

are reserved words within

strict mode code

. (

12.6.2

A conforming implementation, when processing

strict mode code

, must not extend, as described in

syntax of

LegacyOctalIntegerLiteral

, nor extend the syntax of

DecimalIntegerLiteral

include

NonOctalDecimalIntegerLiteral

A conforming implementation, when processing

strict mode code

, may not extend the syntax of

EscapeSequence

to include

LegacyOctalEscapeSequence

NonOctalDecimalEscapeSequence

as described in

B.1.2

Assignment to an undeclared identifier or otherwise unresolvable reference does not create a property in the

global object

. When a simple assignment occurs within

strict mode code

, its

LeftHandSideExpression

must not

evaluate to an unresolvable Reference. If it does a

ReferenceError

exception is thrown (

6.2.4.5

). The

LeftHandSideExpression

also may not be a reference to a

data property

with the attribute value { [[Writable]]:

false

}, to an

accessor property

with the attribute value { [[Set]]:

undefined

}, nor to a non-existent property of

an object whose [[Extensible]] internal slot has the value

false

. In these cases a

TypeError

exception is

thrown (

13.15

Objects with an [[IsHTMLDDA]] internal slot are never created by this specification. However,
the

in web browsers is a

with this slot that

exists for web compatibility purposes. There are no other known examples of this type of object
and implementations should not create any with the exception of

document.all

B.3.7.1 Changes to ToBoolean

B.3.7.2 Changes to Abstract Equality Comparison

B.3.7.3 Changes to the

typeof

Operator

C The Strict Mode of ECMAScript

866

IdentifierReference

with the

StringValue

"eval"

"arguments"

may not appear as the

LeftHandSideExpression

of an Assignment operator (

) or as the

operated upon by a

Prefix Increment (

13.4.4

) or a Prefix Decrement (

13.4.5

) operator.

Arguments objects for strict functions define a non-configurable

accessor property

"callee"

which throws a

TypeError

exception on access (

10.4.4.6

Arguments objects for strict functions do not dynamically share their

array-indexed

property values with the

corresponding formal parameter bindings of their functions. (

10.4.4

For strict functions, if an arguments object is created the binding of the local identifier

arguments

to the

arguments object is immutable and hence may not be the target of an assignment expression. (

10.2.10

It is a

SyntaxError

"eval"

"arguments"

Strict mode eval code cannot instantiate variables or functions in the variable environment of the caller to eval.
Instead, a new variable environment is created and that environment is used for declaration binding
instantiation for the eval code (

19.2.1

this

is evaluated within

strict mode code

, then the

this

value is not coerced to an object. A

this

value of

undefined

null

is not converted to the

global object

and primitive values are not converted to wrapper

objects. The

this

value passed via a function call (including calls made using

Function.prototype.apply

and

Function.prototype.call

) do not coerce the passed

this

value to an object (

10.2.1.2

20.2.3.1

20.2.3.3

When a

delete

operator occurs within

strict mode code

, a

SyntaxError

is thrown if its

UnaryExpression

is a

direct reference to a variable, function argument, or function name (

13.5.1.1

When a

delete

operator occurs within

strict mode code

, a

TypeError

is thrown if the property to be deleted

has the attribute { [[Configurable]]:

false

} or otherwise cannot be deleted (

. The occurrence of a

WithStatement

in such a context is a

SyntaxError

(

14.11.1

It is a

SyntaxError

and

contains either

eval

arguments

appears more than once in the

. An attempt to create such a function using a Function, Generator, or AsyncFunction

SyntaxError

An implementation may not extend, beyond that defined in this specification, the meanings within strict
functions of properties named

"caller"

"arguments"

of function instances.

See

4.2

for the definition of

host

HostCallJobCallback

(...)

HostEnqueueFinalizationRegistryCleanupJob

(...)

HostEnqueuePromiseJob

(...)

HostEnsureCanCompileStrings

(...)

D Host Layering Points

D.1 Host Hooks

867

HostFinalizeImportMeta

(...)

HostGetImportMetaProperties

(...)

HostHasSourceTextAvailable

(...)

HostImportModuleDynamically

(...)

HostMakeJobCallback

(...)

HostPromiseRejectionTracker

(...)

HostResolveImportedModule

(...)

InitializeHostDefinedRealm

Records: See

[[HostDefined]] on Script Records: See

Table 39

[[HostDefined]] on Module Records: See

Table 40

[[HostDefined]] on JobCallback Records: See

Table 27

[[HostSynchronizesWith]] on Candidate Executions: See

[[IsHTMLDDA]]: See

Preparation steps before, and cleanup steps after, invocation of

Job

Abstract Closures. See

9.4

Any of the essential internal methods in

Table 6

for any

exotic object

not specified within this specification.

Any built-in objects and methods not defined within this specification, except as restricted in

17.1

D.2 Host-defined Fields

D.3 Host-defined Objects

D.4 Running Jobs

D.5 Internal Methods of Exotic Objects

D.6 Built-in Objects and Methods

868

9.1.1.4.15

9.1.1.4.18

Edition 5 and 5.1 used a property existence test to determine whether a

global object

property

corresponding to a new global declaration already existed. ECMAScript 2015 uses an own property existence test.
This corresponds to what has been most commonly implemented by web browsers.

10.4.2.1

: The 5

Edition moved the capture of the current array length prior to the

or new length value. However, the captured length value could become invalid if the conversion process has the

side-effect of changing the array length. ECMAScript 2015 specifies that the current array length must be captured
after the possible occurrence of such side-effects.

21.4.1.14

: Previous editions permitted the

TimeClip

abstract operation to return either

𝔽

-0

𝔽

as the representation

of a 0

time value

. ECMAScript 2015 specifies that

𝔽

always returned. This means that for ECMAScript 2015 the

time

value

of a Date object is never observably

-0

𝔽

and methods that return time values never return

-0

𝔽

21.4.1.15

: If a UTC offset representation is not present, the local time zone is used. Edition 5.1 incorrectly stated that a

missing time zone should be interpreted as

"z"

21.4.4.36

: If the year cannot be represented using the Date Time String Format specified in

21.4.1.15

a RangeError

exception is thrown. Previous editions did not specify the behaviour for that case.

21.4.4.41

: Previous editions did not specify the value returned by

Date.prototype.toString

. ECMAScript 2015 specifies the result to be the String value

"Invalid Date"

22.2.3.1

22.2.3.2.5

: Any LineTerminator code points in the value of the

"source"

property of a RegExp instance must be

expressed using an escape sequence. Edition 5.1 only required the escaping of

22.2.5.7

22.2.5.10

: In previous editions, the specifications for

String.prototype.match

and

String.prototype.replace

was incorrect for cases where the pattern argument was a RegExp value whose

global

flag is set. The previous specifications stated that for each attempt to match the pattern, if

lastIndex

did

not change it should be incremented by 1. The correct behaviour is that

lastIndex

should be incremented by one

only if the pattern matched the empty String.

23.1.3.27

23.1.3.27.1

: Previous editions did not specify how a

NaN

value returned by a

comparefn

was interpreted by

Array.prototype.sort

. ECMAScript 2015 specifies that such as value is treated as if

𝔽

was returned from

the

comparefn

. ECMAScript 2015 also specifies that

ToNumber

is applied to the result returned by a

comparefn

. In

previous editions, the effect of a

comparefn

result that is not a

Number value

was

implementation-defined

. In practice,

implementations call

ToNumber

6.2.4

: In ECMAScript 2015, Function calls are not allowed to return a

Reference Record

7.1.4.1

: In ECMAScript 2015,

ToNumber

applied to a String value now recognizes and converts

BinaryIntegerLiteral

and

OctalIntegerLiteral

numeric strings. In previous editions such strings were converted to

NaN

E Corrections and Clarifications in ECMAScript 2015

with Possible Compatibility Impact

F Additions and Changes That Introduce

Incompatibilities with Prior Editions

869

9.2

: In ECMAScript 2018, Template objects are canonicalized based on

Parse Node

(source location), instead of across

all occurrences of that template literal or tagged template in a

Realm

in previous editions.

12.2

: In ECMAScript 2016, Unicode 8.0.0 or higher is mandated, as opposed to ECMAScript 2015 which mandated

Unicode 5.1. In particular, this caused U+180E MONGOLIAN VOWEL SEPARATOR, which was in the

Space_Separator

(

) category and thus treated as whitespace in ECMAScript 2015, to be moved to the

Format

(

) category (as of Unicode 6.3.0). This causes whitespace-sensitive methods to behave differently. For

example,

"\u180E".trim().length

was

in previous editions, but

in ECMAScript 2016 and later.

Additionally, ECMAScript 2017 mandated always using the latest version of the Unicode standard.

12.6

: In ECMAScript 2015, the valid code points for an

IdentifierName

are specified in terms of the Unicode properties

“ID_Start” and “ID_Continue”. In previous editions, the valid

IdentifierName

Identifier

code points were specified by

enumerating various Unicode code point categories.

12.9.1

: In ECMAScript 2015, Automatic Semicolon Insertion adds a semicolon at the end of a do-while statement if the

semicolon is missing. This change aligns the specification with the actual behaviour of most existing implementations.

13.2.6.1

: In ECMAScript 2015, it is no longer an

early error

to have duplicate property names in Object Initializers.

13.15.1

: In ECMAScript 2015,

strict mode code

containing an assignment to an immutable binding such as the function

. Instead it produces a runtime error.

14.2

: In ECMAScript 2015, a

StatementList

beginning with the token let followed by the input elements

LineTerminator

then

Identifier

is the start of a

LexicalDeclaration

. In previous editions, automatic semicolon insertion would always

insert a semicolon before the

Identifier

input element.

14.5

: In ECMAScript 2015, a

StatementListItem

beginning with the token

let

followed by the token

[[

is the start of a

LexicalDeclaration

. In previous editions such a sequence would be the start of an

ExpressionStatement

14.6.2

: In ECMAScript 2015, the normal completion value of an

empty

part is evaluated or if the evaluated

Statement

part produces a normal completion whose value is

empty

, the

completion value of the

IfStatement

undefined

14.7

: In ECMAScript 2015, if the

((

token of a for statement is immediately followed by the token sequence

let [

then the

let

is treated as the start of a

LexicalDeclaration

. In previous editions such a token sequence would be the

start of an

Expression

14.7

: In ECMAScript 2015, if the ( token of a for-in statement is immediately followed by the token sequence

let [

then the

let

is treated as the start of a

ForDeclaration

. In previous editions such a token sequence would be the start

of an

LeftHandSideExpression

14.7

: Prior to ECMAScript 2015, an initialization expression could appear as part of the

VariableDeclaration

that

precedes the

keyword

. In ECMAScript 2015, the

ForBinding

in that same position does not allow the occurrence of

such an initializer. In ECMAScript 2017, such an initializer is permitted only in

non-strict code

14.7

: In ECMAScript 2015, the completion value of an

IterationStatement

is never the value

empty

. If the

is not evaluated or if the final evaluation of the

Statement

part produces a completion whose

value is

empty

, the completion value of the

IterationStatement

undefined

14.11.2

: In ECMAScript 2015, the normal completion value of a

WithStatement

is never the value

empty

. If evaluation of

the

Statement

part of a

WithStatement

produces a normal completion whose value is

empty

, the completion value of the

870

WithStatement

undefined

14.12.4

: In ECMAScript 2015, the completion value of a

empty

produces a completion whose value is

empty

, the completion value of the

SwitchStatement

undefined

14.15

: In ECMAScript 2015, it is an

var

declaration for the same

Identifier

that appears as the

Catch

clause parameter. In previous editions, such a variable declaration would be instantiated in

the enclosing variable environment but the declaration's

Initializer

value would be assigned to the

Catch

parameter.

14.15

19.2.1.3

: In ECMAScript 2015, a runtime

SyntaxError

is thrown if a

Catch

clause evaluates a non-strict direct

eval

whose eval code includes a

var

FunctionDeclaration

declaration that binds the same

that

clause parameter.

: In ECMAScript 2015, the completion value of a

empty

part of a

evaluates to a normal completion whose value is

empty

, the completion value of the

undefined

evaluates to a throw completion and it has a

Catch

part that evaluates to

a normal completion whose value is

empty

, the completion value of the

TryStatement

undefined

if there is no

Finally

clause or if its

Finally

clause evaluates to an

empty

normal completion.

15.4.5

In ECMAScript 2015, the function objects that are created as the values of the [[Get]] or [[Set]] attribute of

accessor properties in an

ObjectLiteral

are not

constructor

functions and they do not have a

"prototype"

own property.

In the previous edition, they were constructors and had a

"prototype"

property.

20.1.2.6

: In ECMAScript 2015, if the argument to

Object.freeze

is not an object it is treated as if it was a non-

extensible

ordinary object

with no own properties. In the previous edition, a non-object argument always causes a

TypeError

to be thrown.

20.1.2.8

: In ECMAScript 2015, if the argument to

Object.getOwnPropertyDescriptor

is not an object an

attempt is made to coerce the argument using

ToObject

. If the coercion is successful the result is used in place of the

original argument value. In the previous edition, a non-object argument always causes a

TypeError

to be thrown.

20.1.2.10

: In ECMAScript 2015, if the argument to

Object.getOwnPropertyNames

is not an object an attempt

is made to coerce the argument using

ToObject

. If the coercion is successful the result is used in place of the original

argument value. In the previous edition, a non-object argument always causes a

TypeError

to be thrown.

20.1.2.12

: In ECMAScript 2015, if the argument to

Object.getPrototypeOf

is not an object an attempt is made

to coerce the argument using

ToObject

. If the coercion is successful the result is used in place of the original argument

value. In the previous edition, a non-object argument always causes a

TypeError

to be thrown.

20.1.2.14

: In ECMAScript 2015, if the argument to

Object.isExtensible

is not an object it is treated as if it was

a non-extensible

ordinary object

with no own properties. In the previous edition, a non-object argument always causes

TypeError

to be thrown.

20.1.2.15

: In ECMAScript 2015, if the argument to

Object.isFrozen

is not an object it is treated as if it was a non-

extensible

ordinary object

with no own properties. In the previous edition, a non-object argument always causes a

TypeError

to be thrown.

20.1.2.16

: In ECMAScript 2015, if the argument to

Object.isSealed

is not an object it is treated as if it was a non-

extensible

ordinary object

with no own properties. In the previous edition, a non-object argument always causes a

TypeError

to be thrown.

871

20.1.2.17

: In ECMAScript 2015, if the argument to

Object.keys

is not an object an attempt is made to coerce the

argument using

ToObject

. If the coercion is successful the result is used in place of the original argument value. In the

previous edition, a non-object argument always causes a

TypeError

to be thrown.

20.1.2.18

: In ECMAScript 2015, if the argument to

Object.preventExtensions

is not an object it is treated as if

it was a non-extensible

ordinary object

with no own properties. In the previous edition, a non-object argument always

causes a

TypeError

to be thrown.

20.1.2.20

: In ECMAScript 2015, if the argument to

Object.seal

is not an object it is treated as if it was a non-

extensible

ordinary object

with no own properties. In the previous edition, a non-object argument always causes a

TypeError

to be thrown.

20.2.3.2

: In ECMAScript 2015, the [[Prototype]] internal slot of a bound function is set to the [[GetPrototypeOf]] value

of its target function. In the previous edition, [[Prototype]] was always set to

%Function.prototype%

20.2.4.1

: In ECMAScript 2015, the

"length"

property of function instances is configurable. In previous editions it was

non-configurable.

20.5.6.2

: In ECMAScript 2015, the [[Prototype]] internal slot of a

NativeError

constructor

is the Error

constructor

. In

previous editions it was the

Function prototype object

21.4.4

In ECMAScript 2015, the

Date prototype object

is not a Date instance. In previous editions it was a Date instance

whose TimeValue was

NaN

22.1.3.10

In ECMAScript 2015, the

String.prototype.localeCompare

function must treat Strings that are

canonically equivalent according to the Unicode standard as being identical. In previous editions implementations
were permitted to ignore canonical equivalence and could instead use a bit-wise comparison.

22.1.3.26

and

22.1.3.28

In ECMAScript 2015, lowercase/upper conversion processing operates on code points. In

previous editions such the conversion processing was only applied to individual code units. The only affected code
points are those in the Deseret block of Unicode.

22.1.3.29

In ECMAScript 2015, the

String.prototype.trim

method is defined to recognize white space code

points that may exists outside of the Unicode BMP. However, as of Unicode 7 no such code points are defined. In
previous editions such code points would not have been recognized as white space.

22.2.3.1

In ECMAScript 2015, If the

pattern

argument is a RegExp instance and the

flags

argument is not

undefined

, a

new RegExp instance is created just like

pattern

except that

pattern

's flags are replaced by the argument

flags

. In

previous editions a

TypeError

exception was thrown when

pattern

was a RegExp instance and

flags

was not

undefined

22.2.5

In ECMAScript 2015, the

RegExp prototype object

is not a RegExp instance. In previous editions it was a

RegExp instance whose pattern is the empty String.

22.2.5

In ECMAScript 2015,

"source"

"global"

"ignoreCase"

, and

"multiline"

are accessor properties defined on the

RegExp prototype object

. In previous editions they were data properties defined on RegExp instances.

25.4.12

: In ECMAScript 2019,

Atomics.wake

has been renamed to

Atomics.notify

to prevent confusion with

Atomics.wait

27.1.4.4

27.6.3.6

: In ECMAScript 2019, the number of Jobs enqueued by

await

was reduced, which could create an

observable difference in resolution order between a

then()

call and an

await

expression.

872

This specification is authored on

GitHub

in a plaintext source format called

Ecmarkup

. Ecmarkup is an HTML and

Markdown dialect that provides a framework and toolset for authoring ECMAScript specifications in plaintext and
processing the specification into a full-featured HTML rendering that follows the editorial conventions for this
document. Ecmarkup builds on and integrates a number of other formats and technologies including

Grammarkdown

for defining syntax and

Ecmarkdown

for authoring algorithm steps. PDF renderings of this

specification are produced by printing the HTML rendering to a PDF.

Prior editions of this specification were authored using Word—the Ecmarkup source text that formed the basis of this
edition was produced by converting the ECMAScript 2015 Word document to Ecmarkup using an automated
conversion tool.

IEEE 754-2019

IEEE Standard for Floating-Point Arithmetic

. Institute of Electrical and Electronic Engineers, New

York (2019)

NOTE

The Unicode Standard

, available at <

https://unicode.org/versions/latest

Unicode Technical Note #5: Canonical Equivalence in Applications

, available at <

https://unicode.org/notes/tn5/

Unicode Technical Standard #10: Unicode Collation Algorithm