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

are used in this specification to operate upon Property Descriptor values:

The abstract operation IsAccessorDescriptor takes argument

Desc

undefined

). It performs

the following steps when called:

1. If

Desc

undefined

, return

false

2. If both

Desc

.[[Get]] and

Desc

.[[Set]] are absent, return

false

3. Return

true

The abstract operation IsDataDescriptor takes argument

Desc

undefined

). It performs the

following steps when called:

1. If

Desc

undefined

, return

false

2. If both

Desc

.[[Value]] and

Desc

.[[Writable]] are absent, return

false

3. Return

true

The abstract operation IsGenericDescriptor takes argument

Desc

undefined

). It performs the

following steps when called:

1. If

Desc

undefined

, return

false

2. If

IsAccessorDescriptor

(

Desc

) and

IsDataDescriptor

(

Desc

) are both

false

, return

true

3. Return

false

The abstract operation FromPropertyDescriptor takes argument

Desc

undefined

). It

performs the following steps when called:

1. If

Desc

undefined

, return

undefined

2. Let

obj

be !

OrdinaryObjectCreate

(

%Object.prototype%

obj

is an extensible

ordinary object

with no own properties.

4. If

Desc

has a [[Value]] field, then

a. Perform !

(

obj

"value"

Desc

.[[Value]]).

5. If

Desc

has a [[Writable]] field, then

a. Perform !

(

obj

"writable"

Desc

.[[Writable]]).

6. If

Desc

has a [[Get]] field, then

6.2.5.1 IsAccessorDescriptor (

Desc

)

6.2.5.2 IsDataDescriptor (

Desc

)

6.2.5.3 IsGenericDescriptor (

Desc

)

6.2.5.4 FromPropertyDescriptor (

Desc

)

107

a. Perform !

(

obj

"get"

Desc

.[[Get]]).

7. If

Desc

has a [[Set]] field, then

a. Perform !

(

obj

"set"

Desc

.[[Set]]).

8. If

Desc

has an [[Enumerable]] field, then

a. Perform !

(

obj

"enumerable"

Desc

.[[Enumerable]]).

9. If

Desc

has a [[Configurable]] field, then

a. Perform !

(

obj

"configurable"

Desc

.[[Configurable]]).

10. Return

obj

The abstract operation ToPropertyDescriptor takes argument

Obj

. It performs the following steps when called:

1. If

(

Obj

) is not Object, throw a

TypeError

exception.

2. Let

desc

be a new

that initially has no fields.

3. Let

hasEnumerable

(

Obj

"enumerable"

4. If

hasEnumerable

true

, then

a. Let

enumerable

Obj

"enumerable"

)).

b. Set

desc

.[[Enumerable]] to

enumerable

5. Let

hasConfigurable

be ?

Obj

"configurable"

6. If

hasConfigurable

true

, then

a. Let

configurable

Obj

"configurable"

)).

b. Set

desc

.[[Configurable]] to

configurable

7. Let

hasValue

be ?

Obj

"value"

8. If

hasValue

true

, then

a. Let

value

be ?

Obj

"value"

b. Set

desc

.[[Value]] to

value

9. Let

hasWritable

(

Obj

"writable"

10. If

hasWritable

true

, then

a. Let

writable

be !

ToBoolean

(

Obj

"writable"

)).

b. Set

desc

.[[Writable]] to

writable

11. Let

hasGet

(

Obj

"get"

12. If

hasGet

true

, then

a. Let

getter

Obj

"get"

b. If

IsCallable

getter

) is

false

and

getter

is not

undefined

, throw a

TypeError

exception.

c. Set

desc

.[[Get]] to

getter

13. Let

hasSet

(

Obj

"set"

14. If

hasSet

true

, then

a. Let

setter

Obj

"set"

b. If

IsCallable

setter

) is

false

and

setter

is not

undefined

, throw a

TypeError

exception.

c. Set

desc

.[[Set]] to

setter

15. If

desc

.[[Get]] is present or

desc

.[[Set]] is present, then

a. If

desc

.[[Value]] is present or

desc

.[[Writable]] is present, throw a

TypeError

exception.

16. Return

desc

The abstract operation CompletePropertyDescriptor takes argument

Desc

). It performs the

6.2.5.5 ToPropertyDescriptor (

Obj

)

6.2.5.6 CompletePropertyDescriptor (

Desc

)

108

following steps when called:

Desc

is a

2. Let

like

be the

Record

{ [[Value]]:

undefined

, [[Writable]]:

false

, [[Get]]:

undefined

, [[Set]]:

undefined

[[Enumerable]]:

false

, [[Configurable]]:

false

3. If

IsGenericDescriptor

Closures are meta-values and are invoked using function application style such as

Desc

) is

true

IsDataDescriptor

(

Desc

) is

true

, then

a. If

Desc

does not have a [[Value]] field, set

Desc

.[[Value]] to

like

.[[Value]].

b. If

Desc

does not have a [[Writable]] field, set

Desc

.[[Writable]] to

like

.[[Writable]].

4. Else,

a. If

Desc

does not have a [[Get]] field, set

Desc

.[[Get]] to

like

.[[Get]].

b. If

Desc

does not have a [[Set]] field, set

Desc

.[[Set]] to

like

.[[Set]].

5. If

Desc

does not have an [[Enumerable]] field, set

Desc

.[[Enumerable]] to

like

.[[Enumerable]].

6. If

Desc

does not have a [[Configurable]] field, set

Desc

.[[Configurable]] to

like

.[[Configurable]].

7. Return

Desc

The

Environment Record

type is used to explain the behaviour of name resolution in nested functions and blocks.

This type and the operations upon it are defined in

9.1

The

Abstract Closure

specification type is used to refer to algorithm steps together with a collection of values. Abstract

, invocations perform the algorithm steps described by the Abstract Closure.

In algorithm steps that create an Abstract Closure, values are captured with the verb "capture" followed by a list of
aliases. When an Abstract Closure is created, it captures the value that is associated with each alias at that time. In
steps that specify the algorithm to be performed when an Abstract Closure is called, each captured value is referred to
by the alias that was used to capture the value.

If an Abstract Closure returns a

Completion Record

, that

Completion Record

's [[Type]] must be either

normal

throw

Abstract Closures are created inline as part of other algorithms, shown in the following example.

1. Let

addend

be 41.

2. Let

closure

be a new

Abstract Closure

with parameters (

) that captures

addend

and performs the following

steps when called:

a. Return

addend

3. Let

val

closure

(1).

val

is 42.

The

Data Block

specification type is used to describe a distinct and mutable sequence of byte-sized (8 bit) numeric

values. A

byte value

is an

value in the range 0 through 255, inclusive. A Data Block value is created with a fixed

number of bytes that each have the initial value 0.

For notational convenience within this specification, an array-like syntax can be used to access the individual bytes of

6.2.6 The Environment Record Specification Type

6.2.7 The Abstract Closure Specification Type

6.2.8 Data Blocks

109

a Data Block value. This notation presents a Data Block value as a 0-origined

The semantics of Shared Data Blocks is defined using Shar ed Data Block events by the

-indexed sequence of bytes. For

example, if

is a 5 byte Data Block value then

[2] can be used to access its 3

byte.

A data block that resides in memory that can be referenced from multiple agents concurrently is designated a

Shared

Data Block

. A Shared Data Block has an identity (for the purposes of equality testing Shared Data Block values) that is

address-free

: it is tied not to the virtual addresses the block is mapped to in any process, but to the set of locations in

memory that the block represents. Two data blocks are equal only if the sets of the locations they contain are equal;
otherwise, they are not equal and the intersection of the sets of locations they contain is empty. Finally, Shared Data
Blocks can be distinguished from Data Blocks.

below introduce Shared Data Block events and act as the interface between evaluation semantics and the

Abstract

operations

event semantics of the

acts as a

filter. Please consult the

for full semantics.

Shared Data Block events are modeled by Records, defined in the

The following

are used in this specification to operate upon Data Block values:

The abstract operation CreateByteDataBlock takes argument

size

(an

). It performs the following steps when

called:

size

≥

2. Let

be a new

Data Block

value consisting of

size

bytes. If it is impossible to create such a

Data Block

, throw a

RangeError

exception.

3. Set all of the bytes of

to 0.

4. Return

The abstract operation CreateSharedByteDataBlock takes argument

size

(a non-negative

). It performs the

following steps when called:

bytes. If it is impossible to create such a

size

≥

2. Let

3. Let

execution

be the [[CandidateExecution]] field of the

surrounding agent

Agent Record

4. Let

eventList

be the [[EventList]] field of the element in

execution

.[[EventsRecords]] whose [[AgentSignifier]] is

AgentSignifier

().

5. Let

zero

be « 0 ».

6. For each index

, do

a. Append

WriteSharedMemory

{ [[Order]]:

Init

, [[NoTear]]:

true

, [[Block]]:

, [[ByteIndex]]:

[[ElementSize]]: 1, [[Payload]]:

zero

} to

eventList

7. Return

The abstract operation CopyDataBlockBytes takes arguments

toBlock

toIndex

(a non-negative

). It performs the following steps when called:

fromBlock

6.2.8.1 CreateByteDataBlock (

size

)

6.2.8.2 CreateSharedByteDataBlock (

size

)

6.2.8.3 CopyDataBlockBytes (

toBlock

toIndex

fromBlock

fromIndex

count

)

110

fromIndex

count

fromBlock

and

toBlock

are distinct

Data Block

Shared Data Block

values.

2. Let

fromSize

be the number of bytes in

fromBlock

fromIndex

count

≤

fromSize

4. Let

toSize

be the number of bytes in

toBlock

whose sole element is a nondeterministically chosen

toIndex

count

≤

toSize

6. Repeat, while

count

> 0,

a. If

fromBlock

is a

Shared Data Block

, then

i. Let

execution

be the [[CandidateExecution]] field of the

surrounding agent

Agent Record

ii. Let

eventList

be the [[EventList]] field of the element in

execution

.[[EventsRecords]] whose

[[AgentSignifier]] is

AgentSignifier

().

iii. Let

bytes

be a

List

byte value

iv. NOTE: In implementations,

bytes

is the result of a non-atomic read instruction on the underlying

hardware. The nondeterminism is a semantic prescription of the

to describe

observable behaviour of hardware with weak consistency.

v. Let

readEvent

ReadSharedMemory

{ [[Order]]:

Unordered

, [[NoTear]]:

true

, [[Block]]:

fromBlock

[[ByteIndex]]:

fromIndex

, [[ElementSize]]: 1 }.

vi. Append

readEvent

eventList

vii. Append

Chosen Value Record

{ [[Event]]:

readEvent

, [[ChosenValue]]:

bytes

} to

execution

[[ChosenValues]].

viii. If

toBlock

1. Append

{ [[Order]]:

Unordered

, [[NoTear]]:

true

, [[Block]]:

toBlock

[[ByteIndex]]:

toIndex

, [[ElementSize]]: 1, [[Payload]]:

bytes

} to

eventList

ix. Else,

1. Set

toBlock

[

toIndex

] to

bytes

[0].

b. Else,

toBlock

is not a

Shared Data Block

ii. Set

toBlock

[

toIndex

] to

fromBlock

[

fromIndex

c. Set

toIndex

+ 1.

d. Set

fromIndex

+ 1.

e. Set

count

- 1.

7. Return

NormalCompletion

(

empty

These operations are not a part of the ECMAScript language; they are defined here solely to aid the specification of the
semantics of the ECMAScript language. Other, more specialized

are defined throughout this

specification.

The ECMAScript language implicitly performs automatic type conversion as needed. To clarify the semantics of
certain constructs it is useful to define a set of conversion

. The conversion

polymorphic; they can accept a value of any

are

ECMAScript language type

. But no other specification types are used

7 Abstract Operations

7.1 Type Conversion

111

with these operations.

The BigInt type has no implicit conversions in the ECMAScript language; programmers must call BigInt explicitly to
convert values from other types.

The abstract operation ToPrimitive takes argument

input

and optional argument

preferredType

. It converts its

input

argument to a non-Object type. If an object is capable of converting to more than one primitive type, it may use the
optional hint

preferredType

to favour that type. It performs the following steps when called:

ECMAScript language value

input

is an

2. If

(

input

) is Object, then

a. Let

exoticToPrim

GetMethod

(

input

@@toPrimitive

b. If

exoticToPrim

is not

undefined

, then

i. If

preferredType

is not present, let

hint

"default"

ii. Else if

preferredType

string

, let

hint

"string"

iii. Else,

preferredType

number

2. Let

hint

"number"

iv. Let

result

be ?

Call

exoticToPrim

input

, «

hint

»).

v. If

(

result

) is not Object, return

result

vi. Throw a

TypeError

exception.

c. If

preferredType

is not present, let

preferredType

number

d. Return ?

OrdinaryToPrimitive

(

input

preferredType

3. Return

input

NOTE

The abstract operation OrdinaryToPrimitive takes arguments

and

hint

. It performs the following steps when called:

) is Object.

hint

is either

string

number

3. If

hint

string

, then

a. Let

methodNames

be «

"toString"

"valueOf"

».

4. Else,

a. Let

methodNames

be «

"valueOf"

"toString"

».

5. For each element

name

methodNames

, do

a. Let

method

be ?

(

name

b. If

IsCallable

method

) is

true

, then

i. Let

result

be ?

Call

method

ii. If

(

result

) is not Object, return

result

When ToPrimitive is called with no hint, then it generally behaves as if the hint were

number

However, objects may over-ride this behaviour by defining a

@@toPrimitive

method. Of the

objects defined in this specification only Date objects (see

21.4.4.45

) and Symbol objects (see

20.4.3.5

) over-ride the default ToPrimitive behaviour. Date objects treat no hint as if the hint were

string

7.1.1 ToPrimitive (

input

[ ,

preferredType

] )

7.1.1.1 OrdinaryToPrimitive (

hint

)

112

6. Throw a

TypeError

exception.

The abstract operation ToBoolean takes argument

argument

. It converts

argument

to a value of type Boolean according

Table 11

Table 11:

ToBoolean

Conversions

Argument

Type

Result

Undefined

Return

false

Null

Return

false

Boolean

Return

argument

Number

argument

𝔽

-0

𝔽

, or

NaN

, return

false

; otherwise return

true

String

argument

is the empty String (its length is 0), return

false

; otherwise return

true

Symbol

Return

true

BigInt

argument

ℤ

, return

false

; otherwise return

true

Object

Return

true

NOTE

The abstract operation ToNumeric takes argument

value

. It returns

value

converted to a Number or a BigInt. It

performs the following steps when called:

1. Let

primValue

(

value

number

2. If

(

primValue

) is BigInt, return

primValue

3. Return ?

(

primValue

The abstract operation ToNumber takes argument

argument

. It converts

argument

to a value of type Number according

Table 12

An alternate algorithm related to the [[IsHTMLDDA]] internal slot is mandated
in section

B.3.7.1

7.1.2 ToBoolean (

argument

)

7.1.3 ToNumeric (

value

)

7.1.4 ToNumber (

argument

)

113

Table 12:

ToNumber

Conversions

Argument Type

Result

Undefined

Return

NaN

Null

Return

𝔽

Boolean

argument

true

, return

𝔽

. If

argument

false

, return

𝔽

Number

Return

argument

(no conversion).

String

See grammar and conversion algorithm below.

Symbol

Throw a

TypeError

exception.

BigInt

Throw a

TypeError

exception.

Object

Apply the following steps:

1. Let

primValue

be ?

argument

number

2. Return ?

primValue

applied to Strings applies the following grammar to the input String interpreted as a sequence of UTF-16

encoded code points (

6.1.4

). If the grammar cannot interpret the String as an expansion of

, then

the result of

NaN

NOTE 1

WhiteSpace
LineTerminator

:::

:::

:::

StrNumericLiteral

:::

StrDecimalLiteral
NonDecimalIntegerLiteral

[~Sep]

The terminal symbols of this grammar are all composed of characters in the Unicode Basic
Multilingual Plane (BMP). Therefore, the result of

will be

NaN

if the string contains

any

leading surrogate

trailing surrogate

code units, whether paired or unpaired.

7.1.4.1 ToNumber Applied to the String Type

Syntax

114

StrDecimalLiteral

:::

:::

Infinity

[~Sep]

[~Sep]

opt

opt

[~Sep]

opt

[~Sep]

[~Sep]

opt

All grammar symbols not explicitly defined above have the definitions used in the Lexical Grammar for numeric
literals (

12.8.3

)

NOTE 2

The conversion of a String to a

is similar overall to the determination of the

for a

numeric literal (see

12.8.3

), but some of the details are different, so the process for converting a String numeric literal

to a value of Number type is given here. This value is determined in two steps: first, a

(MV) is

derived from the String numeric literal; second, this

is rounded as described below. The MV on

any grammar symbol, not provided below, is the MV for that symbol defined in

12.8.3.1

The MV of

:::

[empty] is 0.

The MV of

:::

StrWhiteSpace

is 0.

The MV of

:::

is the MV of

, no matter whether white space is present or not.

The MV of

StrDecimalLiteral

:::

is the negative of the MV of

. (Note that if the MV of

is 0, the negative of this MV is also

0. The rounding rule described below handles the conversion of this signless mathematical zero to a floating-
point

𝔽

-0

𝔽

as appropriate.)

The MV of

:::

Infinity

is 10

10000

(a value so large that it will round to

∞

𝔽

The MV of

:::

is the MV of the first

plus (the MV of the second

times 10

), where

is the number of code points in the second

Some differences should be noted between the syntax of a

and a

NumericLiteral

may include leading and/or trailing white space and/or line

terminators.
A

that is decimal may have any number of leading

digits.

that is decimal may include a

to indicate its sign.

that is empty or contains only white space is converted to

𝔽

Infinity

and

-Infinity

are recognized as a

but not as a

NumericLiteral

cannot include a

BigIntLiteralSuffix

7.1.4.1.1 Runtime Semantics: MV

115

The MV of

:::

where

is the MV of

The MV of

:::

is (the MV of the first

plus (the MV of the second

times 10

)) times 10

, where

is the number of code

points in the second

and

is the MV of

The MV of

:::

, where

is the

number of code points in

The MV of

:::

where

is the number of code points in

and

is the MV of

The MV of

:::

times 10

where

is the MV of

), unless the literal includes a

Once the exact MV for a String numeric literal has been determined, it is then rounded to a value of the Number type.
If the MV is 0, then the rounded value is

𝔽

unless the first non white space code point in the String numeric literal is

, in which case the rounded value is

-0

𝔽

. Otherwise, the rounded value must be the

and the literal has more than 20

significant digits, in which case the

may be either the

for the MV of a literal produced

by replacing each significant digit after the 20th with a 0 digit or the

for the MV of a literal produced by

replacing each significant digit after the 20th with a 0 digit and then incrementing the literal at the 20th digit position.
A digit is significant if it is not part of an

and

it is not

; or

there is a non-zero digit to its left and there is a non-zero digit, not in the

, to its right.

The abstract operation ToIntegerOrInfinity takes argument

argument

. It converts

argument

to an

, +

∞

, or -

∞

. It

performs the following steps when called:

1. Let

number

be ?

argument

2. If

number

NaN

𝔽

, or

-0

𝔽

, return 0.

3. If

number

∞

𝔽

, return +

∞

4. If

number

∞

𝔽

, return -

∞

5. Let

integer

floor

abs

number

))).

6. If

number

𝔽

, set

integer

to -

integer

7. Return

integer

The abstract operation ToInt32 takes argument

argument

. It converts

argument

to one of 2

values in

the range

- 1), inclusive. It performs the following steps when called:

1. Let

number

be ?

argument

2. If

number

NaN

𝔽

-0

𝔽

∞

𝔽

, or

∞

𝔽

, return

𝔽

3. Let

int

be the

that is the same sign as

number

and whose magnitude is

number

))).

4. Let

int32bit

int

7.1.5 ToIntegerOrInfinity (

argument

)

7.1.6 ToInt32 (

argument

)

116

5. If

int32bit

≥

(

int32bit

- 2

); otherwise return

(

int32bit

NOTE

The abstract operation ToUint32 takes argument

argument

. It converts

argument

to one of 2

values

in the range

𝔽

- 1), inclusive. It performs the following steps when called:

1. Let

number

be ?

argument

2. If

number

NaN

𝔽

-0

𝔽

∞

𝔽

, or

∞

𝔽

, return

𝔽

3. Let

int

be the

that is the same sign as

number

and whose magnitude is

number

))).

4. Let

int32bit

int

5. Return

int32bit

NOTE

The abstract operation ToInt16 takes argument

argument

. It converts

argument

to one of 2

values in

the range

- 1), inclusive. It performs the following steps when called:

1. Let

number

be ?

argument

2. If

number

NaN

𝔽

-0

𝔽

∞

𝔽

, or

∞

𝔽

, return

𝔽

3. Let

int

be the

that is the same sign as

number

and whose magnitude is

number

))).

4. Let

int16bit

int

5. If

int16bit

≥

(

int16bit

- 2

); otherwise return

(

int16bit

Given the above definition of ToInt32:

The ToInt32 abstract operation is idempotent: if applied to a result that it produced, the
second application leaves that value unchanged.
ToInt32(

ToUint32

)) is the same value as ToInt32(

) for all values of

. (It is to preserve

this latter property that

∞

𝔽

and

∞

𝔽

are mapped to

𝔽

ToInt32 maps

-0

𝔽

Given the above definition of ToUint32:

Step

is the only difference between ToUint32 and

ToInt32

The ToUint32 abstract operation is idempotent: if applied to a result that it produced, the
second application leaves that value unchanged.
ToUint32(

ToInt32

)) is the same value as ToUint32(

) for all values of

. (It is to preserve

this latter property that

∞

𝔽

and

∞

𝔽

are mapped to

𝔽

ToUint32 maps

-0

𝔽

7.1.7 ToUint32 (

argument

)

7.1.8 ToInt16 (

argument

)

117

The abstract operation ToUint16 takes argument

argument

. It converts

argument

to one of 2

values

in the range

𝔽

- 1), inclusive. It performs the following steps when called:

1. Let

number

be ?

argument

2. If

number

NaN

𝔽

-0

𝔽

∞

𝔽

, or

∞

𝔽

, return

𝔽

3. Let

int

be the

that is the same sign as

number

and whose magnitude is

number

))).

4. Let

int16bit

int

5. Return

int16bit

NOTE

The abstract operation ToInt8 takes argument

argument

. It converts

argument

to one of 2

values in

the range

-128

𝔽

through

127

𝔽

, inclusive. It performs the following steps when called:

1. Let

number

be ?

argument

2. If

number

NaN

𝔽

-0

𝔽

∞

𝔽

, or

∞

𝔽

, return

𝔽

3. Let

int

be the

that is the same sign as

number

and whose magnitude is

number

))).

4. Let

int8bit

int

5. If

int8bit

≥

, return

int8bit

- 2

(

int8bit

The abstract operation ToUint8 takes argument

argument

. It converts

argument

to one of 2

values in

the range

𝔽

through

255

𝔽

, inclusive. It performs the following steps when called:

1. Let

number

be ?

argument

2. If

number

NaN

𝔽

-0

𝔽

∞

𝔽

, or

∞

𝔽

, return

𝔽

3. Let

int

be the

that is the same sign as

number

and whose magnitude is

number

))).

4. Let

int8bit

int

5. Return

int8bit

The abstract operation ToUint8Clamp takes argument

argument

. It converts

argument

to one of 2

Given the above definition of ToUint16:

The substitution of 2

for 2

in step

is the only difference between

ToUint32

and

ToUint16.
ToUint16 maps

-0

𝔽

7.1.9 ToUint16 (

argument

)

7.1.10 ToInt8 (

argument

)

7.1.11 ToUint8 (

argument

)

7.1.12 ToUint8Clamp (

argument

)

118

values in the range

𝔽

through

255

𝔽

, inclusive. It performs the following steps when called:

1. Let

number

be ?

argument

2. If

number

NaN

, return

𝔽

number

)

≤

0, return

𝔽

number

)

≥

255, return

255

𝔽

5. Let

floor

number

)).

6. If

+ 0.5 <

(

number

(

+ 1).

number

) <

(

8. If

(

+ 1).

9. Return

NOTE

The abstract operation ToBigInt takes argument

argument

. It converts

argument

to a BigInt value, or throws if an

implicit conversion from Number would be required. It performs the following steps when called:

1. Let

prim

(

argument

number

2. Return the value that

prim

corresponds to in

Table 13

Table 13: BigInt Conversions

Argument Type

Result

Undefined

Throw a

TypeError

exception.

Null

Throw a

TypeError

exception.

Boolean

Return

prim

true

and

prim

false

BigInt

Return

prim

Number

Throw a

TypeError

exception.

String

1. Let

be !

StringToBigInt

prim

2. If

NaN

, throw a

SyntaxError

exception.

3. Return

Symbol

Throw a

TypeError

exception.

Apply the algorithm in

7.1.4.1

with the following changes:

Unlike the other ECMAScript

conversion abstract operation, ToUint8Clamp rounds

rather than truncates non-integral values and does not convert

∞

𝔽

. ToUint8Clamp does

“round half to even” tie-breaking. This differs from

Math.round

which does “round half up”

tie-breaking.

7.1.13 ToBigInt (

argument

)

7.1.14 StringToBigInt (

argument

)

119

Replace the

pr oduction with

to not allow

Infinity

, decimal points, or

exponents.
If the MV is

NaN

, return

NaN

, otherwise return the BigInt which exactly corresponds to the MV, rather than

rounding to a Number.

The abstract operation ToBigInt64 takes argument

argument

. It converts

argument

to one of 2

BigInt values in the

(-2

) through

-1), inclusive. It performs the following steps when called:

1. Let

ToBigInt

(

argument

2. Let

int64bit

)

3. If

int64bit

≥

(

int64bit

- 2

(

int64bit

The abstract operation ToBigUint64 takes argument

argument

. It converts

argument

to one of 2

BigInt values in the

range

ℤ

through the BigInt value for

-1), inclusive. It performs the following steps when called:

1. Let

ToBigInt

(

argument

2. Let

int64bit

)

3. Return

int64bit

The abstract operation ToString takes argument

argument

. It converts

argument

to a value of type String according to

Table 14

7.1.15 ToBigInt64 (

argument

)

7.1.16 ToBigUint64 (

argument

)

7.1.17 ToString (

argument

)

120

Table 14:

ToString

Conversions

Argument Type

Result

Undefined

Return

"undefined"

Null

Return

"null"

Boolean

argument

true

, return

"true"

argument

false

, return

"false"

Number

Return !

Number::toString

(

argument

String

Return

argument

Symbol

Throw a

TypeError

exception.

BigInt

Return !

BigInt::toString

argument

Object

Apply the following steps:

1. Let

primValue

be ?