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 inclusive range 0xD800 to 0xDBFF (defined by the Unicode Standard as a leading surrogate, or more formally as a highsurrogate code unit) and every code unit with a numeric value in the inclusive range 0xDC00 to 0xDFFF (defined as a trailing surrogate, or more formally as a lowsurrogate code unit) using the following rules:

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 ECMAScript source text is in Normalized Form C, string literals are guaranteed to also be normalized, as long as they do not contain any Unicode escape sequences.
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
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 starting with fromIndex such that i ≤ len  searchLen, in ascending order, do Let candidate be the
substring of string from i to i + searchLen.  If candidate is the same sequence of code units as searchValue, return i.
 Let candidate be the
 Return 1.
If searchValue is the empty String and fromIndex is less than or equal to 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 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. In this specification, every numeric type T contains a multiplicative identity value denoted T::unit. The specification types also have the following
Invocation Synopsis  Example source  Invoked by the Evaluation semantics of ...  Result 

T::unaryMinus(x) 
x

 Operator 
T 
T::bitwiseNOT(x) 
~x

~ ) 
T 
T::exponentiate(x, y) 
x ** y


T, may throw 
T::multiply(x, y) 
x * y


T 
T::divide(x, y) 
x / y


T, may throw 
T::remainder(x, y) 
x % y


T, may throw 
T::add(x, y) 
x ++ ++ x x + y

+ ) 
T 
T::subtract(x, y) 
x   x x  y

 ) 
T 
T::leftShift(x, y) 
x << y

<< ) 
T 
T::signedRightShift(x, y) 
x >> y

>> ) 
T 
T::unsignedRightShift(x, y) 
x >>> y

>>> ) 
T, may throw 
T::lessThan(x, y) 
x < y x > y x <= y x >= y


Boolean or 
T::equal(x, y) 
x == y x != y x === y x !== y


Boolean 
T::sameValue(x, y) 
Object.is(x, y)

Object internal methods,
via 
Boolean 
T::sameValueZero(x, y) 
[x].includes(y)

Array, Map, and Set methods,
via 
Boolean 
T::bitwiseAND(x, y) 
x & y


T 
T::bitwiseXOR(x, y) 
x ^ y


T 
T::bitwiseOR(x, y) 
x  y


T 
T::toString(x) 
String(x)

Many expressions and builtin functions, via 
String 
The T::unit value and T::op 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
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 truncate. These legacy implicit conversions are maintained for backward compatibility, but not provided for BigInt in order to minimize opportunity for programmer error, and to leave open the option of generalized value types in a future edition.
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
The bit pattern that might be observed in an ArrayBuffer (see
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 finite number has an odd significand if it is nonzero and the
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
The
Some ECMAScript operators deal only with
The Number::unit value is
6.1.6.1.1 Number::unaryMinus ( x )
The abstract operation Number::unaryMinus takes argument x (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). It performs the following steps when called:
 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). It returns an
 If exponent is
NaN , returnNaN .  If exponent is
+0 _{𝔽} or exponent is0 _{𝔽}, 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 is finite and is neither+0 _{𝔽} nor0 _{𝔽}. If exponent is
+∞ _{𝔽}, then  If exponent is
∞ _{𝔽}, then Assert : exponent is finite and is neither+0 _{𝔽} nor0 _{𝔽}. If base <
+0 _{𝔽} and exponent is not anintegral Number , returnNaN .  Return an
implementationapproximated 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). It performs multiplication according to the rules of
Finiteprecision multiplication is commutative, but not always associative.
6.1.6.1.5 Number::divide ( x, y )
The abstract operation Number::divide takes arguments x (a Number) and y (a Number). It performs division according to the rules of
 If x is
NaN or y isNaN , returnNaN .  If x is
+∞ _{𝔽} or x is∞ _{𝔽}, then If y is
+∞ _{𝔽} or y is∞ _{𝔽}, returnNaN .  If y is
+0 _{𝔽} or y >+0 _{𝔽}, return x.  Return x.
 If y is
 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
+0 _{𝔽} or x is0 _{𝔽}, then If y is
+0 _{𝔽} or y is0 _{𝔽}, returnNaN .  If y >
+0 _{𝔽}, return x.  Return x.
 If y is
 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). 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
+∞ _{𝔽} or n is∞ _{𝔽}, returnNaN .  If d is
+∞ _{𝔽} or d is∞ _{𝔽}, return n.  If d is
+0 _{𝔽} or d is0 _{𝔽}, returnNaN .  If n is
+0 _{𝔽} or n is0 _{𝔽}, return n. Assert : n and d are finite and nonzero. Let r be
ℝ (n)  (ℝ (d) × q) where q is aninteger that is negative if and only if n and d have opposite sign, and whose magnitude is as large as possible without exceeding the magnitude ofℝ (n) /ℝ (d).  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). 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
+∞ _{𝔽} or x is∞ _{𝔽}, return x.  If y is
+∞ _{𝔽} or y is∞ _{𝔽}, return y. Assert : x and y are both finite. If x is
0 _{𝔽} and y is0 _{𝔽}, return0 _{𝔽}.  Return
𝔽 (ℝ (x) +ℝ (y)).
Finiteprecision addition is commutative, but not always associative.
6.1.6.1.8 Number::subtract ( x, y )
The abstract operation Number::subtract takes arguments x (a Number) and y (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). It performs the following steps when called:
 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). It performs the following steps when called:
 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). It performs the following steps when called:
 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). It performs the following steps when called:
 If x is
NaN , returnundefined .  If y is
NaN , returnundefined .  If x and y are the same
Number value , returnfalse .  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 are finite and nonzero. 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). It performs the following steps when called:
 If x is
NaN , returnfalse .  If y is
NaN , returnfalse .  If x is the same
Number value as y, returntrue .  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). 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 the same
Number value as y, returntrue .  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). 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 the same
Number value as y, returntrue .  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). It performs the following steps when called:
 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
&
, let result be the result of applying the bitwise AND operation to lbits and rbits.  Else if op is
^
, let result be the result of applying the bitwise exclusive OR (XOR) operation to lbits and rbits.  Else, 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). It performs the following steps when called:
 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). It performs the following steps when called:
 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). It performs the following steps when called:
 Return
NumberBitwiseOp (
, x, y).
6.1.6.1.20 Number::toString ( x )
The abstract operation Number::toString takes argument x (a Number). It converts x to String format. It performs the following steps when called:
 If x is
NaN , return the String"NaN" .  If x is
+0 _{𝔽} or0 _{𝔽}, return the String"0" .  If x <
+0 _{𝔽}, return thestringconcatenation of"" and !Number::toString (x).  If x is
+∞ _{𝔽}, return the String"Infinity" .  Otherwise, let n, k, and s be
integers such that k ≥ 1, 10^{k  1} ≤ s < 10^{k},𝔽 (s × 10^{n  k}) is x, and k is as small as possible. Note that k is the number of digits in the decimal representation of s, that s is not divisible by 10, and that the least significant digit of s is not necessarily uniquely determined by these criteria.  If k ≤ n ≤ 21, return the
stringconcatenation of: the code units of the k digits of the decimal representation of s (in order, with no leading zeroes)
 n  k occurrences of the code unit 0x0030 (DIGIT ZERO)
 If 0 < n ≤ 21, return the
stringconcatenation of: the code units of the most significant n digits of the decimal representation of s
 the code unit 0x002E (FULL STOP)
 the code units of the remaining k  n digits of the decimal representation of s
 If 6 < 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 decimal representation of s
 Otherwise, if k = 1, return the
stringconcatenation of:  Return the
stringconcatenation of: the code units 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)
 the code unit 0x002B (PLUS SIGN) or the code unit 0x002D (HYPHENMINUS) according to whether n  1 is positive or negative
 the code units of the decimal representation of the
integer abs (n  1) (with no leading zeroes)
The following observations may be useful as guidelines for implementations, but are not part of the normative requirements of this Standard:

If x is any
Number value other than0 _{𝔽}, thenToNumber (ToString (x)) is exactly the sameNumber value as x. 
The least significant digit of s is not always uniquely determined by the requirements listed in step
5 .
For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step
 Otherwise, let n, k, and s be
integers such that k ≥ 1, 10^{k  1} ≤ s < 10^{k},𝔽 (s × 10^{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 × 10^{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 decimal representation of s and that s is not divisible by 10.
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
The BigInt::unit value is
6.1.6.2.1 BigInt::unaryMinus ( x )
The abstract operation BigInt::unaryMinus takes argument x (a BigInt). It performs the following steps when called:
 If x is
0 _{ℤ}, return0 _{ℤ}.  Return the BigInt value that represents the negation of
ℝ (x).
6.1.6.2.2 BigInt::bitwiseNOT ( x )
The abstract operation BigInt::bitwiseNOT takes argument x (a BigInt). It returns the one's complement of x; that is, x 
6.1.6.2.3 BigInt::exponentiate ( base, exponent )
The abstract operation BigInt::exponentiate takes arguments base (a BigInt) and exponent (a BigInt). It performs the following steps when called:
6.1.6.2.4 BigInt::multiply ( x, y )
The abstract operation BigInt::multiply takes arguments x (a BigInt) and y (a BigInt). It returns the BigInt value that represents the result of multiplying x and y.
6.1.6.2.5 BigInt::divide ( x, y )
The abstract operation BigInt::divide takes arguments x (a BigInt) and y (a BigInt). It performs the following steps when called:
6.1.6.2.6 BigInt::remainder ( n, d )
The abstract operation BigInt::remainder takes arguments n (a BigInt) and d (a BigInt). It performs the following steps when called:
 If d is
0 _{ℤ}, throw aRangeError exception.  If n is
0 _{ℤ}, return0 _{ℤ}.  Let r be the BigInt defined by the mathematical relation r = n  (d × q) where q is a BigInt that is negative only if n/d is negative and positive only if n/d is positive, and whose magnitude is as large as possible without exceeding the magnitude of the true mathematical quotient of n and d.
 Return r.
6.1.6.2.7 BigInt::add ( x, y )
The abstract operation BigInt::add takes arguments x (a BigInt) and y (a BigInt). It returns the BigInt value that represents the sum of x and y.
6.1.6.2.8 BigInt::subtract ( x, y )
The abstract operation BigInt::subtract takes arguments x (a BigInt) and y (a BigInt). It returns the BigInt value that represents the difference x minus y.
6.1.6.2.9 BigInt::leftShift ( x, y )
The abstract operation BigInt::leftShift takes arguments x (a BigInt) and y (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). 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). It performs the following steps when called:
 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). It returns
6.1.6.2.13 BigInt::equal ( x, y )
The abstract operation BigInt::equal takes arguments x (a BigInt) and y (a BigInt). It returns
6.1.6.2.14 BigInt::sameValue ( x, y )
The abstract operation BigInt::sameValue takes arguments x (a BigInt) and y (a BigInt). It performs the following steps when called:
 Return
BigInt::equal (x, y).
6.1.6.2.15 BigInt::sameValueZero ( x, y )
The abstract operation BigInt::sameValueZero takes arguments x (a BigInt) and y (a BigInt). It performs the following steps when called:
 Return
BigInt::equal (x, y).
6.1.6.2.16 BinaryAnd ( x, y )
The abstract operation BinaryAnd takes arguments x (0 or 1) and y (0 or 1). It performs the following steps when called:
 If x is 1 and y is 1, return 1.
 Else, return 0.
6.1.6.2.17 BinaryOr ( x, y )
The abstract operation BinaryOr takes arguments x (0 or 1) and y (0 or 1). It performs the following steps when called:
 If x is 1 or y is 1, return 1.
 Else, return 0.
6.1.6.2.18 BinaryXor ( x, y )
The abstract operation BinaryXor takes arguments x (0 or 1) and y (0 or 1). It performs the following steps when called:
 If x is 1 and y is 0, return 1.
 Else if x is 0 and y is 1, return 1.
 Else, return 0.
6.1.6.2.19 BigIntBitwiseOp ( op, x, y )
The abstract operation BigIntBitwiseOp takes arguments op (&
, ^
, or 
), x (a BigInt), and y (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
&
, let tmp beBinaryAnd (xmodulo 2, ymodulo 2).  Else if op is

, let tmp beBinaryOr (xmodulo 2, ymodulo 2).  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.20 BigInt::bitwiseAND ( x, y )
The abstract operation BigInt::bitwiseAND takes arguments x (a BigInt) and y (a BigInt). It performs the following steps when called:
 Return
BigIntBitwiseOp (&
, x, y).
6.1.6.2.21 BigInt::bitwiseXOR ( x, y )
The abstract operation BigInt::bitwiseXOR takes arguments x (a BigInt) and y (a BigInt). It performs the following steps when called:
 Return
BigIntBitwiseOp (^
, x, y).
6.1.6.2.22 BigInt::bitwiseOR ( x, y )
The abstract operation BigInt::bitwiseOR takes arguments x (a BigInt) and y (a BigInt). It performs the following steps when called:
 Return
BigIntBitwiseOp (
, x, y).
6.1.6.2.23 BigInt::toString ( x )
The abstract operation BigInt::toString takes argument x (a BigInt). It converts x to String format. It performs the following steps when called:
 If x <
0 _{ℤ}, return thestringconcatenation of the String"" and !BigInt::toString (x).  Return the String value consisting of the code units of the digits of the decimal representation of x.
6.1.7 The Object Type
An Object is logically 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.
Properties are identified using key values. A property key value is either an ECMAScript String value or a Symbol value. All String and Symbol values, including the empty String, are valid as property keys. A property name is a property key that is a String value.
An integer index is a Stringvalued property key that is a canonical numeric String (see
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. A
Attribute Name  Value Domain  Description 

[[Value]] 
Any 
The value retrieved by a get access of the property. 
[[Writable]]  Boolean 
If 
[[Enumerable]]  Boolean 
If 
[[Configurable]]  Boolean 
If 
An
Attribute Name  Value Domain  Description 

[[Get]]  Object  Undefined 
If the value is an Object it must be a 
[[Set]]  Object  Undefined 
If the value is an Object it must be a 
[[Enumerable]]  Boolean 
If 
[[Configurable]]  Boolean 
If 
If the initial values of a property's attributes are not explicitly specified by this specification, the default value defined in
Attribute Name  Default Value 

[[Value]] 

[[Get]] 

[[Set]] 

[[Writable]] 

[[Enumerable]] 

[[Configurable]] 

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 6 , the object uses those defined in10.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 .
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 completion with [[Type]] =
[[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 finite length (that is, starting from any object, recursively applying the [[GetPrototypeOf]] internal method to its result should eventually lead to the value
[[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 a fully populatedProperty 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