6.1 ECMAScript Language Types
An ECMAScript language type corresponds to values that are directly manipulated by an ECMAScript programmer using the ECMAScript language. The ECMAScript language types are Undefined, Null, Boolean, String, Symbol, Number, BigInt, and Object. An ECMAScript language value is a value that is characterized by an ECMAScript language type.
6.1.1 The Undefined Type
The Undefined type has exactly one value, called
6.1.2 The Null Type
The Null type has exactly one value, called
6.1.3 The Boolean Type
The Boolean type represents a logical entity having two values, called
6.1.4 The String Type
The String type is the set of all ordered sequences of zero or more 16bit unsigned
ECMAScript operations that do not interpret String contents apply no further semantics. Operations that do interpret String values treat each element as a single UTF16 code unit. However, ECMAScript does not restrict the value of or relationships between these code units, so operations that further interpret String contents as sequences of Unicode code points encoded in UTF16 must account for illformed subsequences. Such operations apply special treatment to every code unit with a numeric value in the

A code unit that is not a
leading surrogate and not atrailing surrogate is interpreted as a code point with the same value. 
A sequence of two code units, where the first code unit c1 is a
leading surrogate and the second code unit c2 atrailing surrogate , is a surrogate pair and is interpreted as a code point with the value (c1  0xD800) × 0x400 + (c2  0xDC00) + 0x10000. (See11.1.3 ) 
A code unit that is a
leading surrogate ortrailing surrogate , but is not part of asurrogate pair , is interpreted as a code point with the same value.
The function String.prototype.normalize
(see String.prototype.localeCompare
(see
The rationale behind this design was to keep the implementation of Strings as simple and highperforming as possible. If
In this specification, the phrase "the stringconcatenation of A, B, ..." (where each argument is a String value, a code unit, or a sequence of code units) denotes the String value whose sequence of code units is the concatenation of the code units (in order) of each of the arguments (in order).
The phrase "the substring of S from inclusiveStart to exclusiveEnd" (where S is a String value or a sequence of code units and inclusiveStart and exclusiveEnd are
The phrase "the ASCII word characters" denotes the following String value, which consists solely of every letter and number in the Unicode Basic Latin block along with U+005F (LOW LINE):
For historical reasons, it has significance to various algorithms.
6.1.4.1 StringIndexOf ( string, searchValue, fromIndex )
The abstract operation StringIndexOf takes arguments string (a String), searchValue (a String), and fromIndex (a nonnegative
 Let len be the length of string.
 If searchValue is the empty String and fromIndex ≤ len, return fromIndex.
 Let searchLen be the length of searchValue.
 For each
integer i such that fromIndex ≤ i ≤ len  searchLen, in ascending order, do Let candidate be the
substring of string from i to i + searchLen.  If candidate is searchValue, return i.
 Let candidate be the
 Return 1.
If searchValue is the empty String and fromIndex ≤ the length of string, this algorithm returns fromIndex. The empty String is effectively found at every position within a string, including after the last code unit.
This algorithm always returns 1 if fromIndex + the length of searchValue > the length of string.
6.1.5 The Symbol Type
The Symbol type is the set of all nonString values that may be used as the key of an Object property (
Each possible Symbol value is unique and immutable.
Each Symbol value immutably holds an associated value called [[Description]] that is either
6.1.5.1 WellKnown Symbols
Wellknown symbols are builtin Symbol values that are explicitly referenced by algorithms of this specification. They are typically used as the keys of properties whose values serve as extension points of a specification algorithm. Unless otherwise specified, wellknown symbols values are shared by all
Within this specification a wellknown symbol is referred to by using a notation of the form @@name, where “name” is one of the values listed in
Specification Name  [[Description]]  Value and Purpose 

@@asyncIterator 

A method that returns the default AsyncIterator for an object. Called by the semantics of the for await of statement.

@@hasInstance 

A method that determines if a instanceof operator.

@@isConcatSpreadable 

A Boolean valued property that if true indicates that an object should be flattened to its array elements by Array.prototype.concat 
@@iterator 

A method that returns the default Iterator for an object. Called by the semantics of the forof statement. 
@@match 

A regular expression method that matches the regular expression against a string. Called by the String.prototype.match 
@@matchAll 

A regular expression method that returns an iterator, that yields matches of the regular expression against a string. Called by the String.prototype.matchAll 
@@replace 

A regular expression method that replaces matched substrings of a string. Called by the String.prototype.replace 
@@search 

A regular expression method that returns the index within a string that matches the regular expression. Called by the String.prototype.search 
@@species 

A function valued property that is the 
@@split 

A regular expression method that splits a string at the indices that match the regular expression. Called by the String.prototype.split 
@@toPrimitive 

A method that converts an object to a corresponding primitive value. Called by the 
@@toStringTag 

A String valued property that is used in the creation of the default string description of an object. Accessed by the builtin method Object.prototype.toString 
@@unscopables 

An object valued property whose own and inherited property names are property names that are excluded from the with environment bindings of the associated object.

6.1.6 Numeric Types
ECMAScript has two builtin numeric types: Number and BigInt. The following
Because the numeric types are in general not convertible without loss of precision or truncation, the ECMAScript language provides no implicit conversion among these types. Programmers must explicitly call Number
and BigInt
functions to convert among types when calling a function which requires another type.
The first and subsequent editions of ECMAScript have provided, for certain operators, implicit numeric conversions that could lose precision or
6.1.6.1 The Number Type
The Number type has exactly 18,437,736,874,454,810,627 (that is, NaN
.) In some implementations, external code might be able to detect a difference between various NotaNumber values, but such behaviour is
There are two other special values, called +Infinity
(or simply Infinity
) and Infinity
.)
The other 18,437,736,874,454,810,624 (that is,
Note that there is both a +0
(or simply 0
) and 0
.)
The 18,437,736,874,454,810,622 (that is,
18,428,729,675,200,069,632 (that is,
where s is 1 or 1, m is an
The remaining 9,007,199,254,740,990 (that is,
where s is 1 or 1, m is an
Note that all the positive and negative
A
In this specification, the phrase “the Number value for x” where x represents an exact real mathematical quantity (which might even be an irrational number such as π) means a Number value chosen in the following manner. Consider the set of all
The
Some ECMAScript operators deal only with
6.1.6.1.1 Number::unaryMinus ( x )
The abstract operation Number::unaryMinus takes argument x (a Number) and returns a Number. It performs the following steps when called:
 If x is
NaN , returnNaN .  Return the result of negating x; that is, compute a Number with the same magnitude but opposite sign.
6.1.6.1.2 Number::bitwiseNOT ( x )
The abstract operation Number::bitwiseNOT takes argument x (a Number) and returns an
 Let oldValue be !
ToInt32 (x).  Return the result of applying bitwise complement to oldValue. The
mathematical value of the result is exactly representable as a 32bit two's complement bit string.
6.1.6.1.3 Number::exponentiate ( base, exponent )
The abstract operation Number::exponentiate takes arguments base (a Number) and exponent (a Number) and returns a Number. It returns an
 If exponent is
NaN , returnNaN .  If exponent is either
+0 _{𝔽} or0 _{𝔽}, return1 _{𝔽}.  If base is
NaN , returnNaN .  If base is
+∞ _{𝔽}, then If exponent >
+0 _{𝔽}, return+∞ _{𝔽}. Otherwise, return+0 _{𝔽}.
 If exponent >
 If base is
∞ _{𝔽}, then If exponent >
+0 _{𝔽}, then If exponent is an odd
integral Number , return∞ _{𝔽}. Otherwise, return+∞ _{𝔽}.
 If exponent is an odd
 Else,
 If exponent is an odd
integral Number , return0 _{𝔽}. Otherwise, return+0 _{𝔽}.
 If exponent is an odd
 If exponent >
 If base is
+0 _{𝔽}, then If exponent >
+0 _{𝔽}, return+0 _{𝔽}. Otherwise, return+∞ _{𝔽}.
 If exponent >
 If base is
0 _{𝔽}, then If exponent >
+0 _{𝔽}, then If exponent is an odd
integral Number , return0 _{𝔽}. Otherwise, return+0 _{𝔽}.
 If exponent is an odd
 Else,
 If exponent is an odd
integral Number , return∞ _{𝔽}. Otherwise, return+∞ _{𝔽}.
 If exponent is an odd
 If exponent >
Assert : base isfinite and is neither+0 _{𝔽} nor0 _{𝔽}. If exponent is
+∞ _{𝔽}, then  If exponent is
∞ _{𝔽}, then Assert : exponent isfinite and is neither+0 _{𝔽} nor0 _{𝔽}. If base <
0 _{𝔽} and exponent is not anintegral Number , returnNaN .  Return an
implementationapproximated Number value representing the result of raisingℝ (base) to theℝ (exponent) power.
The result of base **
exponent when base is
6.1.6.1.4 Number::multiply ( x, y )
The abstract operation Number::multiply takes arguments x (a Number) and y (a Number) and returns a Number. It performs multiplication according to the rules of
 If x is
NaN or y isNaN , returnNaN .  If x is either
+∞ _{𝔽} or∞ _{𝔽}, then If y is either
+0 _{𝔽} or0 _{𝔽}, returnNaN .  If y >
+0 _{𝔽}, return x.  Return x.
 If y is either
 If y is either
+∞ _{𝔽} or∞ _{𝔽}, then If x is either
+0 _{𝔽} or0 _{𝔽}, returnNaN .  If x >
+0 _{𝔽}, return y.  Return y.
 If x is either
 If x is
0 _{𝔽}, then If y is
0 _{𝔽} or y <0 _{𝔽}, return+0 _{𝔽}.  Else, return
0 _{𝔽}.
 If y is
 If y is
0 _{𝔽}, then If x <
0 _{𝔽}, return+0 _{𝔽}.  Else, return
0 _{𝔽}.
 If x <
 Return
𝔽 (ℝ (x) ×ℝ (y)).
6.1.6.1.5 Number::divide ( x, y )
The abstract operation Number::divide takes arguments x (a Number) and y (a Number) and returns a Number. It performs division according to the rules of
 If x is
NaN or y isNaN , returnNaN .  If x is either
+∞ _{𝔽} or∞ _{𝔽}, then If y is either
+∞ _{𝔽} or∞ _{𝔽}, returnNaN .  If y is
+0 _{𝔽} or y >+0 _{𝔽}, return x.  Return x.
 If y is either
 If y is
+∞ _{𝔽}, then If x is
+0 _{𝔽} or x >+0 _{𝔽}, return+0 _{𝔽}. Otherwise, return0 _{𝔽}.
 If x is
 If y is
∞ _{𝔽}, then If x is
+0 _{𝔽} or x >+0 _{𝔽}, return0 _{𝔽}. Otherwise, return+0 _{𝔽}.
 If x is
 If x is either
+0 _{𝔽} or0 _{𝔽}, then If y is either
+0 _{𝔽} or0 _{𝔽}, returnNaN .  If y >
+0 _{𝔽}, return x.  Return x.
 If y is either
 If y is
+0 _{𝔽}, then If x >
+0 _{𝔽}, return+∞ _{𝔽}. Otherwise, return∞ _{𝔽}.
 If x >
 If y is
0 _{𝔽}, then If x >
+0 _{𝔽}, return∞ _{𝔽}. Otherwise, return+∞ _{𝔽}.
 If x >
 Return
𝔽 (ℝ (x) /ℝ (y)).
6.1.6.1.6 Number::remainder ( n, d )
The abstract operation Number::remainder takes arguments n (a Number) and d (a Number) and returns a Number. It yields the remainder from an implied division of its operands where n is the dividend and d is the divisor. It performs the following steps when called:
 If n is
NaN or d isNaN , returnNaN .  If n is either
+∞ _{𝔽} or∞ _{𝔽}, returnNaN .  If d is either
+∞ _{𝔽} or∞ _{𝔽}, return n.  If d is either
+0 _{𝔽} or0 _{𝔽}, returnNaN .  If n is either
+0 _{𝔽} or0 _{𝔽}, return n. Assert : n and d arefinite and nonzero. Let quotient be
ℝ (n) /ℝ (d).  Let q be
truncate (quotient).  Let r be
ℝ (n)  (ℝ (d) × q).  If r = 0 and n <
0 _{𝔽}, return0 _{𝔽}.  Return
𝔽 (r).
In C and C++, the remainder operator accepts only integral operands; in ECMAScript, it also accepts floatingpoint operands.
%
operator is not the same as the “remainder” operation defined by %
on floatingpoint operations to behave in a manner analogous to that of the Java 6.1.6.1.7 Number::add ( x, y )
The abstract operation Number::add takes arguments x (a Number) and y (a Number) and returns a Number. It performs addition according to the rules of
 If x is
NaN or y isNaN , returnNaN .  If x is
+∞ _{𝔽} and y is∞ _{𝔽}, returnNaN .  If x is
∞ _{𝔽} and y is+∞ _{𝔽}, returnNaN .  If x is either
+∞ _{𝔽} or∞ _{𝔽}, return x.  If y is either
+∞ _{𝔽} or∞ _{𝔽}, return y. Assert : x and y are bothfinite . If x is
0 _{𝔽} and y is0 _{𝔽}, return0 _{𝔽}.  Return
𝔽 (ℝ (x) +ℝ (y)).
6.1.6.1.8 Number::subtract ( x, y )
The abstract operation Number::subtract takes arguments x (a Number) and y (a Number) and returns a Number. It performs subtraction, producing the difference of its operands; x is the minuend and y is the subtrahend. It performs the following steps when called:
 Return
Number::add (x,Number::unaryMinus (y)).
It is always the case that x  y
produces the same result as x + (y)
.
6.1.6.1.9 Number::leftShift ( x, y )
The abstract operation Number::leftShift takes arguments x (a Number) and y (a Number) and returns an
 Let lnum be !
ToInt32 (x).  Let rnum be !
ToUint32 (y).  Let shiftCount be
ℝ (rnum)modulo 32.  Return the result of left shifting lnum by shiftCount bits. The
mathematical value of the result is exactly representable as a 32bit two's complement bit string.
6.1.6.1.10 Number::signedRightShift ( x, y )
The abstract operation Number::signedRightShift takes arguments x (a Number) and y (a Number) and returns an
 Let lnum be !
ToInt32 (x).  Let rnum be !
ToUint32 (y).  Let shiftCount be
ℝ (rnum)modulo 32.  Return the result of performing a signextending right shift of lnum by shiftCount bits. The most significant bit is propagated. The
mathematical value of the result is exactly representable as a 32bit two's complement bit string.
6.1.6.1.11 Number::unsignedRightShift ( x, y )
The abstract operation Number::unsignedRightShift takes arguments x (a Number) and y (a Number) and returns an
 Let lnum be !
ToUint32 (x).  Let rnum be !
ToUint32 (y).  Let shiftCount be
ℝ (rnum)modulo 32.  Return the result of performing a zerofilling right shift of lnum by shiftCount bits. Vacated bits are filled with zero. The
mathematical value of the result is exactly representable as a 32bit unsigned bit string.
6.1.6.1.12 Number::lessThan ( x, y )
The abstract operation Number::lessThan takes arguments x (a Number) and y (a Number) and returns a Boolean or
 If x is
NaN , returnundefined .  If y is
NaN , returnundefined .  If x is y, return
false .  If x is
+0 _{𝔽} and y is0 _{𝔽}, returnfalse .  If x is
0 _{𝔽} and y is+0 _{𝔽}, returnfalse .  If x is
+∞ _{𝔽}, returnfalse .  If y is
+∞ _{𝔽}, returntrue .  If y is
∞ _{𝔽}, returnfalse .  If x is
∞ _{𝔽}, returntrue . Assert : x and y arefinite . If
ℝ (x) <ℝ (y), returntrue . Otherwise, returnfalse .
6.1.6.1.13 Number::equal ( x, y )
The abstract operation Number::equal takes arguments x (a Number) and y (a Number) and returns a Boolean. It performs the following steps when called:
 If x is
NaN , returnfalse .  If y is
NaN , returnfalse .  If x is y, return
true .  If x is
+0 _{𝔽} and y is0 _{𝔽}, returntrue .  If x is
0 _{𝔽} and y is+0 _{𝔽}, returntrue .  Return
false .
6.1.6.1.14 Number::sameValue ( x, y )
The abstract operation Number::sameValue takes arguments x (a Number) and y (a Number) and returns a Boolean. It performs the following steps when called:
 If x is
NaN and y isNaN , returntrue .  If x is
+0 _{𝔽} and y is0 _{𝔽}, returnfalse .  If x is
0 _{𝔽} and y is+0 _{𝔽}, returnfalse .  If x is y, return
true .  Return
false .
6.1.6.1.15 Number::sameValueZero ( x, y )
The abstract operation Number::sameValueZero takes arguments x (a Number) and y (a Number) and returns a Boolean. It performs the following steps when called:
 If x is
NaN and y isNaN , returntrue .  If x is
+0 _{𝔽} and y is0 _{𝔽}, returntrue .  If x is
0 _{𝔽} and y is+0 _{𝔽}, returntrue .  If x is y, return
true .  Return
false .
6.1.6.1.16 NumberBitwiseOp ( op, x, y )
The abstract operation NumberBitwiseOp takes arguments op (&
, ^
, or 
), x (a Number), and y (a Number) and returns an
 Let lnum be !
ToInt32 (x).  Let rnum be !
ToInt32 (y).  Let lbits be the 32bit two's complement bit string representing
ℝ (lnum).  Let rbits be the 32bit two's complement bit string representing
ℝ (rnum).  If op is
&
, then Let result be the result of applying the bitwise AND operation to lbits and rbits.
 Else if op is
^
, then Let result be the result of applying the bitwise exclusive OR (XOR) operation to lbits and rbits.
 Else,
Assert : op is
. Let result be the result of applying the bitwise inclusive OR operation to lbits and rbits.
 Return the
Number value for theinteger represented by the 32bit two's complement bit string result.
6.1.6.1.17 Number::bitwiseAND ( x, y )
The abstract operation Number::bitwiseAND takes arguments x (a Number) and y (a Number) and returns an
 Return
NumberBitwiseOp (&
, x, y).
6.1.6.1.18 Number::bitwiseXOR ( x, y )
The abstract operation Number::bitwiseXOR takes arguments x (a Number) and y (a Number) and returns an
 Return
NumberBitwiseOp (^
, x, y).
6.1.6.1.19 Number::bitwiseOR ( x, y )
The abstract operation Number::bitwiseOR takes arguments x (a Number) and y (a Number) and returns an
 Return
NumberBitwiseOp (
, x, y).
6.1.6.1.20 Number::toString ( x, radix )
The abstract operation Number::toString takes arguments x (a Number) and radix (an
 If x is
NaN , return"NaN" .  If x is either
+0 _{𝔽} or0 _{𝔽}, return"0" .  If x <
0 _{𝔽}, return thestringconcatenation of"" andNumber::toString (x, radix).  If x is
+∞ _{𝔽}, return"Infinity" .  Let n, k, and s be
integers such that k ≥ 1, radix^{k  1} ≤ s < radix^{k},𝔽 (s × radix^{n  k}) is x, and k is as small as possible. Note that k is the number of digits in the representation of s using radix radix, that s is not divisible by radix, and that the least significant digit of s is not necessarily uniquely determined by these criteria.  If radix ≠ 10 or n is in the
inclusive interval from 5 to 21, then If n ≥ k, then
 Return the
stringconcatenation of: the code units of the k digits of the representation of s using radix radix
 n  k occurrences of the code unit 0x0030 (DIGIT ZERO)
 Return the
 Else if n > 0, then
 Return the
stringconcatenation of: the code units of the most significant n digits of the representation of s using radix radix
 the code unit 0x002E (FULL STOP)
 the code units of the remaining k  n digits of the representation of s using radix radix
 Return the
 Else,
Assert : n ≤ 0. Return the
stringconcatenation of: the code unit 0x0030 (DIGIT ZERO)
 the code unit 0x002E (FULL STOP)
 n occurrences of the code unit 0x0030 (DIGIT ZERO)
 the code units of the k digits of the representation of s using radix radix
 If n ≥ k, then
 NOTE: In this case, the input will be represented using scientific E notation, such as
1.2e+3
. Assert : radix is 10. If n < 0, then
 Let exponentSign be the code unit 0x002D (HYPHENMINUS).
 Else,
 Let exponentSign be the code unit 0x002B (PLUS SIGN).
 If k = 1, then
 Return the
stringconcatenation of: the code unit of the single digit of s
 the code unit 0x0065 (LATIN SMALL LETTER E)
 exponentSign
 the code units of the decimal representation of
abs (n  1)
 Return the
 Return the
stringconcatenation of: the code unit of the most significant digit of the decimal representation of s
 the code unit 0x002E (FULL STOP)
 the code units of the remaining k  1 digits of the decimal representation of s
 the code unit 0x0065 (LATIN SMALL LETTER E)
 exponentSign
 the code units of the decimal representation of
abs (n  1)
The following observations may be useful as guidelines for implementations, but are not part of the normative requirements of this Standard:
For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step
 Let n, k, and s be
integers such that k ≥ 1, radix^{k  1} ≤ s < radix^{k},𝔽 (s × radix^{n  k}) is x, and k is as small as possible. If there are multiple possibilities for s, choose the value of s for which s × radix^{n  k} is closest in value toℝ (x). If there are two such possible values of s, choose the one that is even. Note that k is the number of digits in the representation of s using radix radix and that s is not divisible by radix.
Implementers of ECMAScript may find useful the paper and code written by David M. Gay for binarytodecimal conversion of floatingpoint numbers:
Gay, David M. Correctly Rounded BinaryDecimal and DecimalBinary Conversions. Numerical Analysis, Manuscript 9010. AT&T Bell Laboratories (Murray Hill, New Jersey). 30 November 1990. Available as
http://ampl.com/REFS/abstracts.html#rounding. Associated code available as
http://netlib.sandia.gov/fp/dtoa.c and as
http://netlib.sandia.gov/fp/g_fmt.c and may also be found at the various netlib
mirror sites.
6.1.6.2 The BigInt Type
The BigInt type represents an
6.1.6.2.1 BigInt::unaryMinus ( x )
The abstract operation BigInt::unaryMinus takes argument x (a BigInt) and returns a BigInt. It performs the following steps when called:
 If x is
0 _{ℤ}, return0 _{ℤ}.  Return x.
6.1.6.2.2 BigInt::bitwiseNOT ( x )
The abstract operation BigInt::bitwiseNOT takes argument x (a BigInt) and returns a BigInt. It returns the one's complement of x. It performs the following steps when called:
 Return x 
1 _{ℤ}.
6.1.6.2.3 BigInt::exponentiate ( base, exponent )
The abstract operation BigInt::exponentiate takes arguments base (a BigInt) and exponent (a BigInt) and returns either a
 If exponent <
0 _{ℤ}, throw aRangeError exception.  If base is
0 _{ℤ} and exponent is0 _{ℤ}, return1 _{ℤ}.  Return base raised to the power exponent.
6.1.6.2.4 BigInt::multiply ( x, y )
The abstract operation BigInt::multiply takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
 Return x × y.
6.1.6.2.5 BigInt::divide ( x, y )
The abstract operation BigInt::divide takes arguments x (a BigInt) and y (a BigInt) and returns either a
6.1.6.2.6 BigInt::remainder ( n, d )
The abstract operation BigInt::remainder takes arguments n (a BigInt) and d (a BigInt) and returns either a
6.1.6.2.7 BigInt::add ( x, y )
The abstract operation BigInt::add takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
 Return x + y.
6.1.6.2.8 BigInt::subtract ( x, y )
The abstract operation BigInt::subtract takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
 Return x  y.
6.1.6.2.9 BigInt::leftShift ( x, y )
The abstract operation BigInt::leftShift takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
6.1.6.2.10 BigInt::signedRightShift ( x, y )
The abstract operation BigInt::signedRightShift takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
 Return
BigInt::leftShift (x, y).
6.1.6.2.11 BigInt::unsignedRightShift ( x, y )
The abstract operation BigInt::unsignedRightShift takes arguments x (a BigInt) and y (a BigInt) and returns a
 Throw a
TypeError exception.
6.1.6.2.12 BigInt::lessThan ( x, y )
The abstract operation BigInt::lessThan takes arguments x (a BigInt) and y (a BigInt) and returns a Boolean. It performs the following steps when called:
6.1.6.2.13 BigInt::equal ( x, y )
The abstract operation BigInt::equal takes arguments x (a BigInt) and y (a BigInt) and returns a Boolean. It performs the following steps when called:
6.1.6.2.14 BinaryAnd ( x, y )
The abstract operation BinaryAnd takes arguments x (0 or 1) and y (0 or 1) and returns 0 or 1. It performs the following steps when called:
 If x = 1 and y = 1, return 1.
 Else, return 0.
6.1.6.2.15 BinaryOr ( x, y )
The abstract operation BinaryOr takes arguments x (0 or 1) and y (0 or 1) and returns 0 or 1. It performs the following steps when called:
 If x = 1 or y = 1, return 1.
 Else, return 0.
6.1.6.2.16 BinaryXor ( x, y )
The abstract operation BinaryXor takes arguments x (0 or 1) and y (0 or 1) and returns 0 or 1. It performs the following steps when called:
 If x = 1 and y = 0, return 1.
 Else if x = 0 and y = 1, return 1.
 Else, return 0.
6.1.6.2.17 BigIntBitwiseOp ( op, x, y )
The abstract operation BigIntBitwiseOp takes arguments op (&
, ^
, or 
), x (a BigInt), and y (a BigInt) and returns a BigInt. It performs the following steps when called:
 Set x to
ℝ (x).  Set y to
ℝ (y).  Let result be 0.
 Let shift be 0.
 Repeat, until (x = 0 or x = 1) and (y = 0 or y = 1),
 If op is
&
, then  Else if op is

, then  Else,
 If tmp ≠ 0, then
 Set result to result  2^{shift}.
 NOTE: This extends the sign.
 Return the
BigInt value for result.
6.1.6.2.18 BigInt::bitwiseAND ( x, y )
The abstract operation BigInt::bitwiseAND takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
 Return
BigIntBitwiseOp (&
, x, y).
6.1.6.2.19 BigInt::bitwiseXOR ( x, y )
The abstract operation BigInt::bitwiseXOR takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
 Return
BigIntBitwiseOp (^
, x, y).
6.1.6.2.20 BigInt::bitwiseOR ( x, y )
The abstract operation BigInt::bitwiseOR takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
 Return
BigIntBitwiseOp (
, x, y).
6.1.6.2.21 BigInt::toString ( x, radix )
The abstract operation BigInt::toString takes arguments x (a BigInt) and radix (an
 If x <
0 _{ℤ}, return thestringconcatenation of"" andBigInt::toString (x, radix).  Return the String value consisting of the representation of x using radix radix.
6.1.7 The Object Type
Each instance of the Object type, also referred to simply as “an Object”, represents a collection of properties. Each property is either a data property, or an accessor property:

A data property associates a key value with an
ECMAScript language value and a set of Boolean attributes. 
An accessor property associates a key value with one or two accessor functions, and a set of Boolean attributes. The accessor functions are used to store or retrieve an
ECMAScript language value that is associated with the property.
The properties of an object are uniquely identified using property keys. A property key is either a String or a Symbol. All Strings and Symbols, including the empty String, are valid as property keys. A property name is a property key that
An integer index is a
Every nonnegative
Property keys are used to access properties and their values. There are two kinds of access for properties: get and set, corresponding to value retrieval and assignment, respectively. The properties accessible via get and set access includes both own properties that are a direct part of an object and inherited properties which are provided by another associated object via a property inheritance relationship. Inherited properties may be either own or inherited properties of the associated object. Each own property of an object must each have a key value that is distinct from the key values of the other own properties of that object.
All objects are logically collections of properties, but there are multiple forms of objects that differ in their semantics for accessing and manipulating their properties. Please see
6.1.7.1 Property Attributes
Attributes are used in this specification to define and explain the state of Object properties as described in
Attribute Name  Types of property for which it is present  Value Domain  Default Value  Description 

[[Value]] 

an 

The value retrieved by a get access of the property. 
[[Writable]] 

a Boolean 

If 
[[Get]] 

an Object or 

If the value 
[[Set]] 

an Object or 

If the value 
[[Enumerable]] 

a Boolean 

If 
[[Configurable]] 

a Boolean 

If 
6.1.7.2 Object Internal Methods and Internal Slots
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
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
All objects have an internal slot named [[PrivateElements]], which is a
Internal methods and internal slots are identified within this specification using names enclosed in double square brackets [[ ]].
An ordinary object is an object that satisfies all of the following criteria:

For the internal methods listed in
Table 4 , the object uses those defined in10.1 . 
If the object has a [[Call]] internal method, it uses either the one defined in
10.2.1 or the one defined in10.3.1 . 
If the object has a [[Construct]] internal method, it uses either the one defined in
10.2.2 or the one defined in10.3.2 .
An exotic object is an object that is not an
This specification recognizes different kinds of
The “Signature” column of
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
Internal Method  Signature  Description 

[[GetPrototypeOf]]  ( ) → Object  Null 
Determine the object that provides inherited properties for this object. A 
[[SetPrototypeOf]]  (Object  Null) → Boolean 
Associate this object with another object that provides inherited properties. Passing 
[[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 
[[GetOwnProperty]] 
(propertyKey) → Undefined  
Return a 
[[DefineOwnProperty]]  (propertyKey, PropertyDescriptor) → Boolean 
Create or alter the own property, whose key is propertyKey, to have the state described by PropertyDescriptor. Return 
[[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 
[[Set]]  (propertyKey, value, Receiver) → Boolean 
Set the value of the property whose key is propertyKey to value. If any ECMAScript code must be executed to set the property value, Receiver is used as the 
[[Delete]]  (propertyKey) → Boolean 
Remove the own property whose key is propertyKey from this object. Return 
[[OwnPropertyKeys]] 
( ) → 
Return a 
Internal Method  Signature  Description 

[[Call]] 
(any, a 
Executes code associated with this object. Invoked via a function call expression. The arguments to the internal method are a 
[[Construct]] 
(a 
Creates an object. Invoked via the new operator or a super call. The first argument to the internal method is a super call. The second argument is the object to which the new operator was initially applied. Objects that implement this internal method are called 
The semantics of the essential internal methods for
6.1.7.3 Invariants of the Essential Internal Methods
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
Any implementation provided
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.
Definitions:
 The target of an internal method is the object upon which the internal method is called.

A target is nonextensible if it has been observed to return
false from its [[IsExtensible]] internal method, ortrue from its [[PreventExtensions]] internal method.  A nonexistent property is a property that does not exist as an own property on a nonextensible target.

All references to
SameValue are according to the definition of theSameValue algorithm.
Return value:
The value returned by any internal method must be a
 [[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]] = anyECMAScript language value .
An internal method must not return a
[[GetPrototypeOf]] ( )
 The normal return type is either Object or Null.

If target is nonextensible, and [[GetPrototypeOf]] returns a value V, then any future calls to [[GetPrototypeOf]] should return the
SameValue as V.
An object's prototype chain should have
[[SetPrototypeOf]] ( V )
 The normal return type is Boolean.

If target is nonextensible, [[SetPrototypeOf]] must return
false , unless V is theSameValue as the target's observed [[GetPrototypeOf]] value.
[[IsExtensible]] ( )
 The normal return type is Boolean.

If [[IsExtensible]] returns
false , all future calls to [[IsExtensible]] on the target must returnfalse .
[[PreventExtensions]] ( )
 The normal return type is Boolean.

If [[PreventExtensions]] returns
true , all future calls to [[IsExtensible]] on the target must returnfalse and the target is now considered nonextensible.
[[GetOwnProperty]] ( P )

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 afully populated Property Descriptor . 
If P is described as a nonconfigurable, nonwritable own
data property , all future calls to [[GetOwnProperty]] ( P ) must returnProperty Descriptor whose [[Value]] isSameValue as P's [[Value]] attribute. 
If P's attributes other than [[Writable]] may change over time or if the property might be deleted, then P's [[Configurable]] attribute must be
true . 
If the [[Writable]] attribute may change from
false totrue , then the [[Configurable]] attribute must betrue . 
If the target is nonextensible and P is nonexistent, then all future calls to [[GetOwnProperty]] (P) on the target must describe P as nonexistent (i.e. [[GetOwnProperty]] (P) must return
undefined ).
As a consequence of the third invariant, if a property is described as a
[[DefineOwnProperty]] ( P, Desc )
 The normal return type is Boolean.

[[DefineOwnProperty]] must return
false if P has previously been observed as a nonconfigurable own property of the target, unless either:
P is a writable
data property . A nonconfigurable writabledata property can be changed into a nonconfigurable nonwritabledata property . 
All attributes of Desc are the
SameValue as P's attributes.

P is a writable

[[DefineOwnProperty]] (P, Desc) must return
false if target is nonextensible and P is a nonexistent own property. That is, a nonextensible target object cannot be extended with new properties.
[[HasProperty]] ( P )
 The normal return type is Boolean.

If P was previously observed as a nonconfigurable own data or
accessor property of the target, [[HasProperty]] must returntrue .
[[Get]] ( P, Receiver )

The normal return type is any
ECMAScript language type . 
If P was previously observed as a nonconfigurable, nonwritable own
data property of the target with value V, then [[Get]] must return theSameValue as V. 
If P was previously observed as a nonconfigurable own
accessor property of the target whose [[Get]] attribute isundefined , the [[Get]] operation must returnundefined .
[[Set]] ( P, V, Receiver )
 The normal return type is Boolean.

If P was previously observed as a nonconfigurable, nonwritable own
data property of the target, then [[Set]] must returnfalse unless V is theSameValue as P's [[Value]] attribute. 
If P was previously observed as a nonconfigurable own
accessor property of the target whose [[Set]] attribute isundefined , the [[Set]] operation must returnfalse .
[[Delete]] ( P )
 The normal return type is Boolean.

If P was previously observed as a nonconfigurable own data or
accessor property of the target, [[Delete]] must returnfalse .
[[OwnPropertyKeys]] ( )

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 nonconfigurable own properties that have previously been observed. 
If the target is nonextensible, the returned
List must contain only the keys of all own properties of the target that are observable using [[GetOwnProperty]].
[[Call]] ( )

The normal return type is any
ECMAScript language type .
[[Construct]] ( )
 The normal return type is Object.
 The target must also have a [[Call]] internal method.
6.1.7.4 WellKnown Intrinsic Objects
Wellknown intrinsics are builtin objects that are explicitly referenced by the algorithms of this specification and which usually have
Within this specification a reference such as %name% means the intrinsic object, associated with the current
Intrinsic Name  Global Name  ECMAScript Language Association 


AggregateError

The AggregateError 

Array

The Array 

ArrayBuffer

The ArrayBuffer 

The prototype of Array iterator objects ( 


The prototype of asyncfromsync iterator objects ( 


The 


The 


An object that all standard builtin async iterator objects indirectly inherit from  

Atomics

The Atomics object ( 

BigInt

The BigInt 

BigInt64Array

The BigInt64Array 

BigUint64Array

The BigUint64Array 

Boolean

The Boolean 

DataView

The DataView 

Date

The Date 

decodeURI

The decodeURI function ( 

decodeURIComponent

The decodeURIComponent function ( 

encodeURI

The encodeURI function ( 

encodeURIComponent

The encodeURIComponent function ( 

Error

The Error 

eval

The eval function ( 

EvalError

The EvalError 

FinalizationRegistry

The 

Float32Array

The Float32Array 

Float64Array

The Float64Array 

The prototype of ForIn iterator objects ( 


Function

The Function 

The 


Int8Array

The Int8Array 

Int16Array

The Int16Array 

Int32Array

The Int32Array 

isFinite

The isFinite function ( 

isNaN

The isNaN function ( 

An object that all standard builtin iterator objects indirectly inherit from  

JSON

The JSON object ( 

Map

The Map 

The prototype of Map iterator objects ( 


Math

The Math object ( 

Number

The Number 

Object

The Object 

parseFloat

The parseFloat function ( 

parseInt

The parseInt function ( 

Promise

The Promise 

Proxy

The Proxy 

RangeError

The RangeError 

ReferenceError

The ReferenceError 

Reflect

The Reflect object ( 

RegExp

The RegExp 

The prototype of RegExp String Iterator objects ( 


Set

The Set 

The prototype of Set iterator objects ( 


SharedArrayBuffer

The SharedArrayBuffer 

String

The String 

The prototype of String iterator objects ( 


Symbol

The Symbol 

SyntaxError

The SyntaxError 

A 


The super class of all typed Array 


TypeError

The TypeError 

Uint8Array

The Uint8Array 

Uint8ClampedArray

The Uint8ClampedArray 

Uint16Array

The Uint16Array 

Uint32Array

The Uint32Array 

URIError

The URIError 

WeakMap

The WeakMap 

WeakRef

The 

WeakSet

The WeakSet 
Additional entries in