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

sole argument each time a set access of the property is performed. The effect of a
property's [[Set]] internal method may, but is not required to, have an effect on the
value returned by subsequent calls to the property's [[Get]] internal method.

[[Enumerable]]

Boolean

true

, the property is to be enumerated by a for-in enumeration (see

14.7.5

Otherwise, the property is said to be non-enumerable.

[[Configurable]] Boolean

false

, attempts to delete the property, change the property to be a

data property

, or

change its attributes will fail.

If the initial values of a property's attributes are not explicitly specified by this specification, the default value defined
in

Table 5

is used.

Table 5: Default Attribute Values

Attribute Name Default Value

[[Value]]

undefined

[[Get]]

undefined

[[Set]]

undefined

[[Writable]]

false

[[Enumerable]]

false

[[Configurable]]

false

The actual semantics of objects, in ECMAScript, are specified via algorithms called

internal methods

. Each object in an

ECMAScript engine is associated with a set of internal methods that defines its runtime behaviour. These internal
methods are not part of the ECMAScript language. They are defined by this specification purely for expository
purposes. However, each object within an implementation of ECMAScript must behave as specified by the internal
methods associated with it. The exact manner in which this is accomplished is determined by the implementation.

Internal method names are polymorphic. This means that different object values may perform different algorithms
when a common internal method name is invoked upon them. That actual object upon which an internal method is
invoked is the “target” of the invocation. If, at runtime, the implementation of an algorithm attempts to use an
internal method of an object that the object does not support, a

TypeError

exception is thrown.

Internal slots correspond to internal state that is associated with objects and used by various ECMAScript
specification algorithms. Internal slots are not object properties and they are not inherited. Depending upon the
specific internal slot specification, such state may consist of values of any

ECMAScript language type

or of specific

ECMAScript specification type values. Unless explicitly specified otherwise, internal slots are allocated as part of the
process of creating an object and may not be dynamically added to an object. Unless specified otherwise, the initial
value of an internal slot is the value

undefined

. Various algorithms within this specification create objects that have

internal slots. However, the ECMAScript language provides no direct way to associate internal slots with an object.

Internal methods and internal slots are identified within this specification using names enclosed in double square
brackets [[ ]].

Table 6

summarizes the

essential internal methods

used by this specification that are applicable to all objects created or

manipulated by ECMAScript code. Every object must have algorithms for all of the essential internal methods.
However, all objects do not necessarily use the same algorithms for those methods.

ordinary object

is an object that satisfies all of the following criteria:

For the internal methods listed in

Table 6

, the object uses those defined in

10.1

If the object has a [[Call]] internal method, it uses the one defined in

10.2.1

If the object has a [[Construct]] internal method, it uses the one defined in

10.2.2

exotic object

is an object that is not an

ordinary object

This specification recognizes different kinds of exotic objects by those objects' internal methods. An object that is

6.1.7.2 Object Internal Methods and Internal Slots

behaviourally equivalent to a particular kind of

bound function exotic

object

), but does not have the same collection of internal methods specified for that kind, is not recognized as that

kind of

exotic object

The “Signature” column of

Table 6

The invocation pattern always includes a parenthesized list of descriptive parameter names. If a parameter name is
the same as an ECMAScript type name then the name describes the required type of the parameter value. If an
internal method explicitly returns a value, its parameter list is followed by the symbol “

→

” and the type name of the

returned value. The type names used in signatures refer to the types defined in clause

augmented by the following

additional names. “

any

” means the value may be any

ECMAScript language type

In addition to its parameters, an internal method always has access to the object that is the target of the method
invocation.

An internal method implicitly returns a

Completion Record

, either a normal completion that wraps a value of the

return type shown in its invocation pattern, or a throw completion.

Table 6: Essential Internal Methods

Internal Method

Signature

Description

[[GetPrototypeOf]]

( )

→

Object |

Null

Determine the object that provides inherited properties for this object.
A

null

value indicates that there are no inherited properties.

[[SetPrototypeOf]]

(Object | Null)

→

Boolean

Associate this object with another object that provides inherited
properties. Passing

null

indicates that there are no inherited

properties. Returns

true

indicating that the operation was completed

successfully or

false

indicating that the operation was not successful.

[[IsExtensible]]

( )

→

Boolean

Determine whether it is permitted to add additional properties to this
object.

[[PreventExtensions]]

( )

→

Boolean

Control whether new properties may be added to this object. Returns

true

if the operation was successful or

false

if the operation was

unsuccessful.

[[GetOwnProperty]]

(

propertyKey

)

→

Undefined |

Property
Descriptor

Return a

Property Descriptor

for the own property of this object

whose key is

propertyKey

, or

undefined

if no such property exists.

[[DefineOwnProperty]] (

propertyKey

PropertyDescriptor

)

→

Boolean

Create or alter the own property, whose key is

propertyKey

, to have the

state described by

PropertyDescriptor

. Return

true

if that property was

successfully created/updated or

false

if the property could not be

created or updated.

[[HasProperty]]

(

propertyKey

)

→

Boolean

Return a Boolean value indicating whether this object already has
either an own or inherited property whose key is

propertyKey

[[Get]]

(

propertyKey

Receiver

)

→

any

Return the value of the property whose key is

propertyKey

from this

object. If any ECMAScript code must be executed to retrieve the
property value,

Receiver

is used as the

this

value when evaluating the

code.

[[Set]]

(

propertyKey

value

Receiver

)

→

Boolean

Set the value of the property whose key is

propertyKey

value

. If any

ECMAScript code must be executed to set the property value,

Receiver

is used as the

this

value when evaluating the code. Returns

true

if the

property value was set or

false

if it could not be set.

[[Delete]]

(

propertyKey

)

→

Boolean

Remove the own property whose key is

propertyKey

from this object.

Return

false

if the property was not deleted and is still present.

Return

true

if the property was deleted or is not present.

[[OwnPropertyKeys]]

( )

→

List

propertyKey

Return a

List

whose elements are all of the own property keys for the

object.

Table 7

summarizes additional essential internal methods that are supported by objects that may be called as

functions. A

function object

is an object that supports the [[Call]] internal method. A

constructor

is an object that

supports the [[Construct]] internal method. Every object that supports [[Construct]] must support [[Call]]; that is,

. Therefore, a

may also be referred to as a

Table 7: Additional Essential Internal Methods of Function Objects

Internal

Method

Signature

Description

[[Call]]

(

any

, a

List

any

)

→

any

Executes code associated with this object. Invoked via a function call expression. The
arguments to the internal method are a

this

value and a

List

whose elements are the

arguments passed to the function by a call expression. Objects that implement this
internal method are

callable

[[Construct]] (a

List

any

Object)

→

Object

Creates an object. Invoked via the

new

operator or a

super

call. The first argument to

the internal method is a

List

whose elements are the arguments of the

constructor

invocation or the

super

call. The second argument is the object to which the

new

operator was initially applied. Objects that implement this internal method are called

constructors

. A

function objects do not have a [[Construct]] internal method.

The semantics of the essential internal methods for ordinary objects and standard exotic objects are specified in clause

. If any specified use of an internal method of an

exotic object

is not supported by an implementation, that usage

must throw a

TypeError

exception when attempted.

The Internal Methods of Objects of an ECMAScript engine must conform to the list of invariants specified below.
Ordinary ECMAScript Objects as well as all standard exotic objects in this specification maintain these invariants.
ECMAScript Proxy objects maintain these invariants by means of runtime checks on the result of traps invoked on the
[[ProxyHandler]] object.

Any implementation provided exotic objects must also maintain these invariants for those objects. Violation of these
invariants may cause ECMAScript code to have unpredictable behaviour and create security issues. However,
violation of these invariants must never compromise the memory safety of an implementation.

An implementation must not allow these invariants to be circumvented in any manner such as by providing
alternative interfaces that implement the functionality of the essential internal methods without enforcing their
invariants.

The

target

of an internal method is the object upon which the internal method is called.

A target is

non-extensible

if it has been observed to return

false

from its [[IsExtensible]] internal method, or

true

from its [[PreventExtensions]] internal method.
A

non-existent

property is a property that does not exist as an own property on a non-extensible target.

All references to

SameValue

are according to the definition of the

SameValue

algorithm.

The value returned by any internal method must be a

Completion Record

with either:

6.1.7.3 Invariants of the Essential Internal Methods

Definitions:

Return value:

[[Type]] =

normal

, [[Target]] =

empty

, and [[Value]] = a value of the "normal return type" shown below for that

internal method, or
[[Type]] =

throw

, [[Target]] =

empty

, and [[Value]] = any

ECMAScript language value

NOTE 1

The normal return type is either Object or Null.
If target is non-extensible, and [[GetPrototypeOf]] returns a value

, then any future calls to [[GetPrototypeOf]]

should return the

SameValue

NOTE 2

The normal return type is Boolean.
If target is non-extensible, [[SetPrototypeOf]] must return

false

, unless

is the

SameValue

as the target's

observed [[GetPrototypeOf]] value.

The normal return type is Boolean.
If [[IsExtensible]] returns

false

, all future calls to [[IsExtensible]] on the target must return

false

The normal return type is Boolean.
If [[PreventExtensions]] returns

true

, all future calls to [[IsExtensible]] on the target must return

false

and the

target is now considered non-extensible.

The normal return type is either

Property Descriptor

or Undefined.

If the Type of the return value is

Property Descriptor

, the return value must be a fully populated

Property

Descriptor

is described as a non-configurable, non-writable own

data property

, all future calls to [[GetOwnProperty]]

(

) must return

Property Descriptor

whose [[V alue]] is

SameValue

's [[Value]] attribute.

's attributes other than [[Writable]] may change over time or if the property might be deleted, then

[[Configurable]] attribute must be

true

If the [[Writable]] attribute may change from

false

true

, then the [[Configurable]] attribute must be

true

If the target is non-extensible and

is non-existent, then all future calls to [[GetOwnProperty]] (

) on the target

must describe

as non-existent (i.e. [[GetOwnProperty]] (

) must return

undefined

An internal method must not return a completion with [[Type]] =

continue

break

, or

return

An object's prototype chain should have finite length (that is, starting from any object, recursively
applying the [[GetPrototypeOf]] internal method to its result should eventually lead to the value

null

). However, this requirement is not enforceable as an object level invariant if the prototype

chain includes any exotic objects that do not use the

ordinary object

definition of

[[GetPrototypeOf]]. Such a circular prototype chain may result in infinite loops when accessing
object properties.

[[GetPrototypeOf]] ( )

[[SetPrototypeOf]] (

)

[[IsExtensible]] ( )

[[PreventExtensions]] ( )

[[GetOwnProperty]] (

)

NOTE 3

The normal return type is Boolean.
[[DefineOwnProperty]] must return

false

has previously been observed as a non-configurable own

property of the target, unless either:

is a writable

data property

. A non-configurable writable

data property

can be changed into a non-

configurable non-writable

data property

2. All attributes of

Desc

are the

SameValue

's attributes.

[[DefineOwnProperty]] (

Desc

) must return

false

if target is non-extensible and

is a non-existent own

property. That is, a non-extensible target object cannot be extended with new properties.

The normal return type is Boolean.
If

was previously observed as a non-configurable own data or

accessor property

of the target,

[[HasProperty]] must return

true

The normal return type is any

ECMAScript language type

was previously observed as a non-configurable, non-writable own

data property

of the target with value

then [[Get]] must return the

SameValue

was previously observed as a non-configurable own

accessor property

of the target whose [[Get]] attribute

undefined

, the [[Get]] operation must return

undefined

The normal return type is Boolean.
If

was previously observed as a non-configurable, non-writable own

data property

of the target, then [[Set]]

must return

false

unless

is the

SameValue

's [[Value]] attribute.

was previously observed as a non-configurable own

accessor property

of the target whose [[Set]] attribute

undefined

, the [[Set]] operation must return

false

The normal return type is Boolean.
If

was previously observed as a non-configurable own data or

accessor property

of the target, [[Delete]] must

return

false

The normal return type is

List

The returned

List

must not contain any duplicate entries.

The Type of each element of the returned

List

is either String or Symbol.

The returned

List

must contain at least the keys of all non-configurable own properties that have previously

been observed.

As a consequence of the third invariant, if a property is described as a

data property

and it may

return different values over time, then either or both of the [[Writable]] and [[Configurable]]
attributes must be

true

even if no mechanism to change the value is exposed via the other

essential internal methods.

[[DefineOwnProperty]] (

Desc

)

[[HasProperty]] (

)

[[Get]] (

Receiver

)

[[Set]] (

Receiver

)

[[Delete]] (

)

[[OwnPropertyKeys]] ( )

If the target is non-extensible, the returned

List

must contain only the keys of all own properties of the target

that are observable using [[GetOwnProperty]].

The normal return type is any

ECMAScript language type

The normal return type is Object.
The target must also have a [[Call]] internal method.

Well-known intrinsics are built-in objects that are explicitly referenced by the algorithms of this specification and
which usually have

realm

-specific identities. Unless otherwise specified each intrinsic object actually corresponds to a

set of similar objects, one per

realm

Within this specification a reference such as %name% means the intrinsic object, associated with the current

realm

corresponding to the name. A reference such as %name.a.b% means, as if the "b" property of the "a" property of the
intrinsic object %name% was accessed prior to any ECMAScript code being evaluated. Determination of the current

realm

and its intrinsics is described in

9.3

. The well-known intrinsics are listed in

Table 8

Table 8: Well-Known Intrinsic Objects

Intrinsic Name

Global Name

ECMAScript Language Association

%AggregateError%

AggregateError

The

AggregateError

(

)

Array

ArrayBuffer

The ArrayBuffer

constructor

(

25.1.3

)

%ArrayIteratorPrototype%

The prototype of Array iterator objects
(

23.1.5

)

%AsyncFromSyncIteratorPrototype%

The prototype of async-from-sync iterator
objects (

)

of async function objects

(

27.7.1

)

%AsyncGeneratorFunction%

The

constructor

of async iterator objects

(

27.4.1

)

%AsyncIteratorPrototype%

An object that all standard built-in async
iterator objects indirectly inherit from

%Atomics%

Atomics

The

Atomics

object (

25.4

)

%BigInt%

BigInt

The BigInt

BigInt64Array

(

[[Call]] ( )

[[Construct]] ( )

6.1.7.4 Well-Known Intrinsic Objects

BigUint64Array

)

Boolean

The Boolean

)

DataView

The DataView

)

Date

The Date

)

decodeURI

The

decodeURI

function (

19.2.6.2

)

%decodeURIComponent%

decodeURIComponent

The

decodeURIComponent

function

(

19.2.6.3

)

%encodeURI%

encodeURI

The

encodeURI

function (

19.2.6.4

)

%encodeURIComponent%

encodeURIComponent

The

encodeURIComponent

function

(

19.2.6.5

)

%Error%

Error

The Error

)

eval

The

eval

function (

19.2.1

)

%EvalError%

EvalError

The EvalError

constructor

(

20.5.5.1

)

%FinalizationRegistry%

FinalizationRegistry

(

Float32Array

The Float32Array

)

Float64Array

The Float64Array

constructor

(

23.2

)

%ForInIteratorPrototype%

The prototype of For-In iterator objects
(

14.7.5.10

)

%Function%

Function

The Function

)

of generator objects (

27.3.1

)

%Int8Array%

Int8Array

The Int8Array

)

Int16Array

)

Int32Array

)

isFinite

The

isFinite

function (

19.2.2

)

%isNaN%

isNaN

The

isNaN

function (

19.2.3

)

%IteratorPrototype%

An object that all standard built-in iterator
objects indirectly inherit from

%JSON%

JSON

The

JSON

)

Map

%MapIteratorPrototype%

The prototype of Map iterator objects
(

24.1.5

)

%Math%

Math

The

Math

object (

21.3

)

%Number%

Number

The Number

)

Object

parseFloat

The

parseFloat

function (

19.2.4

)

%parseInt%

parseInt

The

parseInt

function (

19.2.5

)

%Promise%

Promise

The Promise

)

Proxy

The Proxy

)

RangeError

The RangeError

constructor

(

20.5.5.2

)

%ReferenceError%

ReferenceError

The ReferenceError

)

Reflect

The

Reflect

object (

28.1

)

%RegExp%

RegExp

The RegExp

constructor

(

22.2.3

)

%RegExpStringIteratorPrototype%

The prototype of RegExp String Iterator
objects (

)

Set

(

%SetIteratorPrototype%

The prototype of Set iterator objects (

24.2.5

)

%SharedArrayBuffer%

SharedArrayBuffer

The SharedArrayBuffer

)

String

(

%StringIteratorPrototype%

The prototype of String iterator objects
(

22.1.5

)

%Symbol%

Symbol

The Symbol

)

SyntaxError

The SyntaxError

throws a new instance of

%TypeError%

%TypedArray%

The super class of all typed Array
constructors (

23.2.1

)

%TypeError%

TypeError

The TypeError

)

Uint8Array

The Uint8Array

Uint8ClampedArray

The Uint8ClampedArray

)

Uint16Array

The Uint16Array

)

Uint32Array

The Uint32Array

)

URIError

The URIError

WeakMap

The WeakMap

WeakRef

)

WeakSet

The WeakSet

NOTE

A specification type corresponds to meta-values that are used within algorithms to describe the semantics of
ECMAScript language constructs and ECMAScript language types. The specification types include Reference,

. Specification type values

are specification artefacts that do not necessarily correspond to any specific entity within an ECMAScript
implementation. Specification type values may be used to describe intermediate results of ECMAScript expression
evaluation but such values cannot be stored as properties of objects or values of ECMAScript language variables.

The

List

type is used to explain the evaluation of argument lists (see

13.3.8

) in

new

expressions, in function calls, and

in other algorithms where a simple ordered list of values is needed. Values of the List type are simply ordered
sequences of list elements containing the individual values. These sequences may be of any length. The elements of a
list may be randomly accessed using 0-origin indices. For notational convenience an array-like syntax can be used to

access List elements. For example,

arguments

[2] is shorthand for saying the 3

element of the List

arguments

When an algorithm iterates over the elements of a List without specifying an order, the order used is the order of the
elements in the List.

For notational convenience within this specification, a literal syntax can be used to express a new List value. For
example, « 1, 2 » defines a List value that has two elements each of which is initialized to a specific value. A new
empty List can be expressed as « ».

The

Record

type is used to describe data aggregations within the algorithms of this specification. A Record type value

consists of one or more named fields. The value of each field is either an ECMAScript value or an abstract value
represented by a name associated with the Record type. Field names are always enclosed in double brackets, for
example [[Value]].

For notational convenience within this specification, an object literal-like syntax can be used to express a Record value.
For example, { [[Field1]]: 42, [[Field2]]:

false

, [[Field3]]:

empty

} defines a Record value that has three fields, each of

which is initialized to a specific value. Field name order is not significant. Any fields that are not explicitly listed are
considered to be absent.

In specification text and algorithms, dot notation may be used to refer to a specific field of a Record value. For
example, if R is the record shown in the previous paragraph then R.[[Field2]] is shorthand for “the field of R named
[[Field2]]”.

Schema for commonly used Record field combinations may be named, and that name may be used as a prefix to a

Additional entries in

Table 82

6.2 ECMAScript Specification Types

6.2.1 The List and Record Specification Types

100

literal Record value to identify the specific kind of aggregations that is being described. For example:
PropertyDescriptor { [[Value]]: 42, [[Writable]]:

false

, [[Configurable]]:

true

The

Set

type is used to explain a collection of unordered elements for use in the

memory model

. Values of the Set type

are simple collections of elements, where no element appears more than once. Elements may be added to and
removed from Sets. Sets may be unioned, intersected, or subtracted from each other.

The

Relation

type is used to explain constraints on Sets. Values of the Relation type are Sets of ordered pairs of values

from its value domain. For example, a Relation on events is a set of ordered pairs of events. For a Relation

and two

values

and

in the value domain of

is shorthand for saying the ordered pair (

) is a member of

. A

Relation is least with respect to some conditions when it is the smallest Relation that satisfies those conditions.

strict partial order

is a Relation value

that satisfies the following.

For all

, and

's domain:

It is not the case that

, and

and

, then

NOTE 1

strict total order

is a Relation value

that satisfies the following.

For all

, and

's domain:

is identical to

, and

It is not the case that

, and

and

, then

NOTE 2

The Completion type is a

Record

used to explain the runtime propagation of values and control flow such as the

behaviour of statements (

break

continue

return

and

throw

) that perform nonlocal transfers of control.

Values of the Completion type are

Record

values whose fields ar e defined by

Table 9

. Such values are referred to as

Completion Record

Table 9:

Completion Record

Fields

Field Name

Value

Meaning

[[Type]]

One of

normal

break

continue

return

, or

throw

The type of completion that occurred.

[[Value]]

any

ECMAScript language value

empty

The value that was produced.

[[Target]]

any ECMAScript string or

empty

The target label for directed control transfers.

The two properties above are called irreflexivity and transitivity, respectively.

The three properties above are called totality, irreflexivity, and transitivity, respectively.

6.2.2 The Set and Relation Specification Types

6.2.3 The Completion Record Specification Type

101

The term “

abrupt completion

” refers to any completion with a [[Type]] value other than

normal

Algorithm steps that say

1. Let

completion

Await

(

value

mean the same thing as:

1. Let

asyncContext

be the

running execution context

2. Let

promise

be ?

PromiseResolve

(

%Promise%

value

3. Let

stepsFulfilled

be the algorithm steps defined in

Await Fulfilled Functions

4. Let

lengthFulfilled

be the number of non-optional parameters of the function definition in

Await Fulfilled

Functions

5. Let

onFulfilled

be !

CreateBuiltinFunction

(

stepsFulfilled

lengthFulfilled

, « [[AsyncContext]] »).

6. Set

onFulfilled

.[[AsyncContext]] to

asyncContext

7. Let

stepsRejected

be the algorithm steps defined in

Await Rejected Functions

8. Let

lengthRejected

be the number of non-optional parameters of the function definition in

Await Rejected

Functions

9. Let

onRejected

be !

CreateBuiltinFunction

(

stepsRejected

lengthRejected

, « [[AsyncContext]] »).

10. Set

onRejected

.[[AsyncContext]] to

asyncContext

11. Perform !

PerformPromiseThen

(

promise

onFulfilled

onRejected

12. Remove

asyncContext

from the

execution context stack

and restore the

execution context

that is at the top of the

execution context stack

as the

running execution context

13. Set the code evaluation state of

asyncContext

such that when evaluation is resumed with a

Completion

completion

, the following steps of the algorithm that invoked

Await

will be performed, with

completion

available.

14. Return.
15. NOTE: This returns to the evaluation of the operation that had most previously resumed evaluation of

asyncContext

where all aliases in the above steps, with the exception of

completion

, are ephemeral and visible only in the steps

pertaining to Await.

NOTE

Await

fulfilled function is an anonymous built-in function that is used as part of the

Await

specification device to

deliver the promise fulfillment value to the caller as a normal completion. Each

Await

fulfilled function has an

[[AsyncContext]] internal slot.

Await can be combined with the

and

prefixes, so that for example

1. Let

result

be ?

Await

(

value

means the same thing as:

1. Let

result

Await

(

value

ReturnIfAbrupt

(

result

6.2.3.1 Await

6.2.3.1.1 Await Fulfilled Functions

102

When an

Await

fulfilled function is called with argument

value

, the following steps are taken:

1. Let

be the

active function object

2. Let

asyncContext

.[[AsyncContext]].

3. Let

prevContext

be the

running execution context

4. Suspend

prevContext

5. Push

asyncContext

onto the

execution context stack

;

asyncContext

is now the

running execution context

6. Resume the suspended evaluation of

asyncContext

using

NormalCompletion

(

value

) as the result of the

operation that suspended it.

Assert

: When we reach this step,

asyncContext

has already been removed from the

execution context stack

and

prevContext

is the currently

running execution context

8. Return

undefined

The

"length"

property of an

Await

fulfilled function is

𝔽

Await

rejected function is an anonymous built-in function that is used as part of the

Await

specification device to

deliver the promise rejection reason to the caller as an abrupt throw completion. Each

Await

rejected function has an

[[AsyncContext]] internal slot.

When an

Await

rejected function is called with argument

reason

, the following steps are taken:

1. Let

be the

active function object

2. Let

asyncContext

.[[AsyncContext]].

3. Let

prevContext

be the

running execution context

4. Suspend

prevContext

5. Push

asyncContext

onto the

execution context stack

;

asyncContext

is now the

running execution context

6. Resume the suspended evaluation of

asyncContext

using

ThrowCompletion

(

reason

) as the result of the

operation that suspended it.

Assert

: When we reach this step,

asyncContext

has already been removed from the

execution context stack

and

prevContext

is the currently

running execution context

8. Return

undefined

The

"length"

property of an

Await

rejected function is

𝔽

The abstract operation NormalCompletion with a single

argument

, such as:

1. Return

NormalCompletion

(

argument

Is a shorthand that is defined as follows:

1. Return

Completion

{ [[Type]]:

normal

, [[Value]]:

argument

, [[Target]]:

empty

The abstract operation ThrowCompletion with a single

argument

, such as:

1. Return

ThrowCompletion

(

argument

6.2.3.1.2 Await Rejected Functions

6.2.3.2 NormalCompletion

6.2.3.3 ThrowCompletion

103

Is a shorthand that is defined as follows:

1. Return

Completion

{ [[Type]]:

throw

, [[Value]]:

argument

, [[Target]]:

empty

The abstract operation UpdateEmpty takes arguments

completionRecord

and

value

. It performs the following steps

when called:

Assert

: If

completionRecord

.[[Type]] is either

return

throw

, then

completionRecord

.[[Value]] is not

empty

2. If

completionRecord

.[[Value]] is not

empty

, return

Completion

(

completionRecord

3. Return

Completion

{ [[Type]]:

completionRecord

.[[Type]], [[Value]]:

value

, [[Target]]:

completionRecord

.[[Target]] }.

The

Reference Record

type is used to explain the behaviour of such operators as

delete

typeof

, the assignment

operators, the

super

keyword

and other language features. For example, the left-hand operand of an assignment is

expected to produce a Reference Record.

A Reference Record is a resolved name or property binding; its fields are defined by

Table 10

Table 10:

Reference Record

Fields

Field Name

Value

Meaning

[[Base]]

One of:

any

ECMAScript
language
value

except

undefined

null

Environment
Record

, or

unresolvable

The value or

Environment Record

which holds the binding. A [[Base]]

unresolvable

indicates that the binding could not be resolved.

[[ReferencedName]] String or Symbol

The name of the binding. Always a String if [[Base]] value is an

Environment Record

[[Strict]]

Boolean

true

if the

Reference Record

originated in

strict mode code

false

otherwise.

[[ThisValue]]

any

ECMAScript

language value

empty

If not

empty

, the

Reference Record

represents a property binding that

was expressed using the

super

keyword

; it is called a

Super Reference

Record

and its [[Base]] value will never be an

Environment Record

. In

that case, the [[ThisValue]] field holds the

this

value at the time the

Reference Record

was created.

6.2.3.4 UpdateEmpty (

completionRecord

value

)

6.2.4 The Reference Record Specification Type

104

The following

abstract operations

are used in this specification to operate upon References:

The abstract operation IsPropertyReference takes argument

. It performs the following steps when called:

Assert

is a

Reference Record

2. If

.[[Base]] is

unresolvable

, return

false

3. If

Type

(

.[[Base]]) is Boolean, String, Symbol, BigInt, Number, or Object, return

true

; otherwise return

false

The abstract operation IsUnresolvableReference takes argument

. It performs the following steps when called:

Assert

is a

Reference Record

2. If

.[[Base]] is

unresolvable

, return

true

; otherwise return

false

The abstract operation IsSuperReference takes argument

. It performs the following steps when called:

Assert

is a

Reference Record

2. If

.[[ThisValue]] is not

empty

, return

true

; otherwise return

false

The abstract operation GetValue takes argument

. It performs the following steps when called:

ReturnIfAbrupt

(

2. If

is not a

Reference Record

, return

3. If

IsUnresolvableReference

(

) is

true

, throw a

ReferenceError

exception.

4. If

IsPropertyReference

(

) is

true

, then

a. Let

baseObj

be !

ToObject

(

.[[Base]]).

b. Return ?

baseObj

.[[Get]](

.[[ReferencedName]],

GetThisValue

(

)).

5. Else,

a. Let

base

.[[Base]].

Assert

base

is an

Environment Record

c. Return ?

base

.GetBindingValue(

.[[ReferencedName]],

.[[Strict]]) (see

9.1

NOTE

The abstract operation PutValue takes arguments

and

. It performs the following steps when called:

The object that may be created in step

4.a

is not accessible outside of the above abstract operation

and the

ordinary object

[[Get]] internal method. An implementation might choose to avoid the

actual creation of the object.

6.2.4.1 IsPropertyReference (

)

6.2.4.2 IsUnresolvableReference (

)

6.2.4.3 IsSuperReference (

)

6.2.4.4 GetValue (

)

6.2.4.5 PutValue (

)

105

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