Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://tc39.es/ecma262/multipage/ecmascript-data-types-and-values.html below:

ECMAScript® 2026 Language Specification

Algorithms within this specification manipulate values each of which has an associated type. The possible value types are exactly those defined in this clause. Types are further classified into ECMAScript language types and specification 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.

The Undefined type has exactly one value, called undefined . Any variable that has not been assigned a value has the value undefined .

The Null type has exactly one value, called null .

The Boolean type represents a logical entity having two values, called true and false .

The String type is the set of all ordered sequences of zero or more 16-bit unsigned integer values (“elements”) up to a maximum length of 2⁵³ - 1 elements. The String type is generally used to represent textual data in a running ECMAScript program, in which case each element in the String is treated as a UTF-16 code unit value. Each element is regarded as occupying a position within the sequence. These positions are indexed with non-negative integers . The first element (if any) is at index 0, the next element (if any) at index 1, and so on. The length of a String is the number of elements (i.e., 16-bit values) within it. The empty String has length zero and therefore contains no elements.

ECMAScript operations that do not interpret String contents apply no further semantics. Operations that do interpret String values treat each element as a single UTF-16 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 UTF-16 must account for ill-formed subsequences. Such operations apply special treatment to every code unit with a numeric value in the inclusive interval from 0xD800 to 0xDBFF (defined by the Unicode Standard as a leading surrogate, or more formally as a high-surrogate code unit) and every code unit with a numeric value in the inclusive interval from 0xDC00 to 0xDFFF (defined as a trailing surrogate, or more formally as a low-surrogate code unit) using the following rules:

• A code unit that is not a leading surrogate and not a trailing 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 a trailing surrogate , is a surrogate pair and is interpreted as a code point with the value (c1 - 0xD800) × 0x400 + (c2 - 0xDC00) + 0x10000. (See 11.1.3 )
• A code unit that is a leading surrogate or trailing surrogate , but is not part of a surrogate pair , is interpreted as a code point with the same value.

The function String.prototype.normalize (see 22.1.3.15 ) can be used to explicitly normalize a String value. String.prototype.localeCompare (see 22.1.3.12 ) internally normalizes String values, but no other operations implicitly normalize the strings upon which they operate. Operation results are not language- and/or locale-sensitive unless stated otherwise.

The rationale behind this design was to keep the implementation of Strings as simple and high-performing 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 string-concatenation 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 integers ) denotes the String value consisting of the consecutive code units of S beginning at index inclusiveStart and ending immediately before index exclusiveEnd (which is the empty String when inclusiveStart = exclusiveEnd). If the "to" suffix is omitted, the length of S is used as the value of exclusiveEnd.

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):
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_" .
For historical reasons, it has significance to various algorithms.

The abstract operation StringIndexOf takes arguments string (a String), searchValue (a String), and fromIndex (a non-negative integer ) and returns a non-negative integer or not-found . It performs the following steps when called:

1. Let len be the length of string.
2. If searchValue is the empty String and fromIndex ≤ len, return fromIndex.
3. Let searchLen be the length of searchValue.
4. For each integer i such that fromIndex ≤ i ≤ len - searchLen, in ascending order, do
   1. Let candidate be the substring of string from i to i + searchLen.
   2. If candidate is searchValue, return i.
5. Return not-found .

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 not-found if fromIndex + the length of searchValue > the length of string.

The abstract operation StringLastIndexOf takes arguments string (a String), searchValue (a String), and fromIndex (a non-negative integer ) and returns a non-negative integer or not-found . It performs the following steps when called:

1. Let len be the length of string.
2. Let searchLen be the length of searchValue.
3. Assert : fromIndex + searchLen ≤ len.
4. For each integer i such that 0 ≤ i ≤ fromIndex, in descending order, do
   1. Let candidate be the substring of string from i to i + searchLen.
   2. If candidate is searchValue, return i.
5. Return not-found .

If searchValue is the empty String, this algorithm returns fromIndex. The empty String is effectively found at every position within a string, including after the last code unit.

The Symbol type is the set of all non-String values that may be used as the key of an Object property ( 6.1.7 ).

Each possible Symbol value is unique and immutable.

Each Symbol value immutably holds an associated value called [[Description]] that is either undefined or a String value.

Well-known symbols are built-in 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, well-known symbols values are shared by all realms ( 9.3 ).

Within this specification a well-known symbol is referred to using the standard intrinsic notation where the intrinsic is one of the values listed in Table 1 .

Previous editions of this specification used a notation of the form @@name, where the current edition would use %Symbol.name%. In particular, the following names were used: @@asyncIterator, @@hasInstance, @@isConcatSpreadable, @@ iterator , @@match, @@matchAll, @@replace, @@search, @@species, @@split, @@toPrimitive, @@toStringTag, and @@unscopables.

ECMAScript has two built-in numeric types: Number and BigInt. The following abstract operations are defined over these numeric types. The "Result" column shows the return type, along with an indication if it is possible for some invocations of the operation to return an abrupt completion .

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.

The Number type has exactly 18,437,736,874,454,810,627 (that is, 2 ⁶⁴ - 2 ⁵³ + 3 ) values, representing the double-precision floating point IEEE 754-2019 binary64 values as specified in the IEEE Standard for Binary Floating-Point Arithmetic, except that the 9,007,199,254,740,990 (that is, 2 ⁵³ - 2 ) distinct NaN values of the IEEE Standard are represented in ECMAScript as a single special NaN value. (Note that the NaN value is produced by the program expression NaN.) In some implementations, external code might be able to detect a difference between various NaN values, but such behaviour is implementation-defined ; to ECMAScript code, all NaN values are indistinguishable from each other.

The bit pattern that might be observed in an ArrayBuffer (see 25.1 ) or a SharedArrayBuffer (see 25.2 ) after a Number value has been stored into it is not necessarily the same as the internal representation of that Number value used by the ECMAScript implementation.

There are two other special values, called positive Infinity and negative Infinity . For brevity, these values are also referred to for expository purposes by the symbols +∞ _𝔽 and -∞ _𝔽, respectively. (Note that these two infinite Number values are produced by the program expressions +Infinity (or simply Infinity) and -Infinity.)

The other 18,437,736,874,454,810,624 (that is, 2 ⁶⁴ - 2 ⁵³ ) values are called the finite numbers. Half of these are positive numbers and half are negative numbers; for every finite positive Number value there is a corresponding negative value having the same magnitude.

Note that there is both a positive zero and a negative zero . For brevity, these values are also referred to for expository purposes by the symbols +0 _𝔽 and -0 _𝔽, respectively. (Note that these two different zero Number values are produced by the program expressions +0 (or simply 0) and -0.)

The 18,437,736,874,454,810,622 (that is, 2 ⁶⁴ - 2 ⁵³ - 2 ) finite non-zero values are of two kinds:

18,428,729,675,200,069,632 (that is, 2 ⁶⁴ - 2 ⁵⁴ ) of them are normalized, having the form

s × m × 2^e

where s is 1 or -1, m is an integer in the interval from 2⁵² (inclusive) to 2⁵³ (exclusive), and e is an integer in the inclusive interval from -1074 to 971.

The remaining 9,007,199,254,740,990 (that is, 2 ⁵³ - 2 ) values are denormalized, having the form

s × m × 2^e

where s is 1 or -1, m is an integer in the interval from 0 (exclusive) to 2⁵² (exclusive), and e is -1074.

Note that all the positive and negative integers whose magnitude is no greater than 2⁵³ are representable in the Number type. The integer 0 has two representations in the Number type: +0 _𝔽 and -0 _𝔽.

A finite number has an odd significand if it is non-zero and the integer m used to express it (in one of the two forms shown above) is odd. Otherwise, it has an even significand.

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 finite values of the Number type, with -0 _𝔽 removed and with two additional values added to it that are not representable in the Number type, namely 2¹⁰²⁴ (which is +1 × 2 ⁵³ × 2 ⁹⁷¹ ) and -2 ¹⁰²⁴ (which is -1 × 2 ⁵³ × 2 ⁹⁷¹ ). Choose the member of this set that is closest in value to x. If two values of the set are equally close, then the one with an even significand is chosen; for this purpose, the two extra values 2¹⁰²⁴ and -2 ¹⁰²⁴ are considered to have even significands. Finally, if 2¹⁰²⁴ was chosen, replace it with +∞ _𝔽; if -2 ¹⁰²⁴ was chosen, replace it with -∞ _𝔽; if +0 _𝔽 was chosen, replace it with -0 _𝔽 if and only if x < 0; any other chosen value is used unchanged. The result is the Number value for x. (This procedure corresponds exactly to the behaviour of the IEEE 754-2019 roundTiesToEven mode.)

The Number value for +∞ is +∞ _𝔽, and the Number value for -∞ is -∞ _𝔽.

Some ECMAScript operators deal only with integers in specific ranges such as the inclusive interval from -2 ³¹ to 2 ³¹ - 1 or the inclusive interval from 0 to 2 ¹⁶ - 1 . These operators accept any value of the Number type but first convert each such value to an integer value in the expected range. See the descriptions of the numeric conversion operations in 7.1 .

The abstract operation Number::unaryMinus takes argument x (a Number) and returns a Number. It performs the following steps when called:

1. If x is NaN , return NaN .
2. Return the negation of x; that is, compute a Number with the same magnitude but opposite sign.

The abstract operation Number::bitwiseNOT takes argument x (a Number) and returns an integral Number . It performs the following steps when called:

1. Let oldValue be !  ToInt32 (x).
2. Return the bitwise complement of oldValue. The mathematical value of the result is exactly representable as a 32-bit two's complement bit string.

The abstract operation Number::exponentiate takes arguments base (a Number) and exponent (a Number) and returns a Number. It returns an implementation-approximated value representing the result of raising base to the exponent power. It performs the following steps when called:

1. If exponent is NaN , return NaN .
2. If exponent is either +0 _𝔽 or -0 _𝔽, return 1 _𝔽.
3. If base is NaN , return NaN .
4. If base is +∞ _𝔽, then
   1. If exponent > +0 _𝔽, return +∞ _𝔽. Otherwise, return +0 _𝔽.
5. If base is -∞ _𝔽, then
   1. If exponent > +0 _𝔽, then
      1. If exponent is an odd integral Number , return -∞ _𝔽. Otherwise, return +∞ _𝔽.
   2. Else,
      1. If exponent is an odd integral Number , return -0 _𝔽. Otherwise, return +0 _𝔽.
6. If base is +0 _𝔽, then
   1. If exponent > +0 _𝔽, return +0 _𝔽. Otherwise, return +∞ _𝔽.
7. If base is -0 _𝔽, then
   1. If exponent > +0 _𝔽, then
      1. If exponent is an odd integral Number , return -0 _𝔽. Otherwise, return +0 _𝔽.
   2. Else,
      1. If exponent is an odd integral Number , return -∞ _𝔽. Otherwise, return +∞ _𝔽.
8. Assert : base is finite and is neither +0 _𝔽 nor -0 _𝔽.
9. If exponent is +∞ _𝔽, then
   1. If abs ( ℝ (base)) > 1, return +∞ _𝔽.
   2. If abs ( ℝ (base)) = 1, return NaN .
   3. If abs ( ℝ (base)) < 1, return +0 _𝔽.
10. If exponent is -∞ _𝔽, then
    1. If abs ( ℝ (base)) > 1, return +0 _𝔽.
    2. If abs ( ℝ (base)) = 1, return NaN .
    3. If abs ( ℝ (base)) < 1, return +∞ _𝔽.
11. Assert : exponent is finite and is neither +0 _𝔽 nor -0 _𝔽.
12. If base < -0 _𝔽 and exponent is not an integral Number , return NaN .
13. Return an implementation-approximated Number value representing the result of raising ℝ (base) to the ℝ (exponent) power.

The result of base ** exponent when base is 1 _𝔽 or -1 _𝔽 and exponent is +∞ _𝔽 or -∞ _𝔽, or when base is 1 _𝔽 and exponent is NaN , differs from IEEE 754-2019 . The first edition of ECMAScript specified a result of NaN for this operation, whereas later revisions of IEEE 754 specified 1 _𝔽. The historical ECMAScript behaviour is preserved for compatibility reasons.

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 IEEE 754-2019 binary double-precision arithmetic, producing the product of x and y. It performs the following steps when called:

1. If x is NaN or y is NaN , return NaN .
2. If x is either +∞ _𝔽 or -∞ _𝔽, then
   1. If y is either +0 _𝔽 or -0 _𝔽, return NaN .
   2. If y > +0 _𝔽, return x.
   3. Return -x.
3. If y is either +∞ _𝔽 or -∞ _𝔽, then
   1. If x is either +0 _𝔽 or -0 _𝔽, return NaN .
   2. If x > +0 _𝔽, return y.
   3. Return -y.
4. If x is -0 _𝔽, then
   1. If y is -0 _𝔽 or y < -0 _𝔽, return +0 _𝔽.
   2. Else, return -0 _𝔽.
5. If y is -0 _𝔽, then
   1. If x < -0 _𝔽, return +0 _𝔽.
   2. Else, return -0 _𝔽.
6. Return 𝔽 ( ℝ (x) × ℝ (y)).

Finite -precision multiplication is commutative, but not always associative.

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 IEEE 754-2019 binary double-precision arithmetic, producing the quotient of x and y where x is the dividend and y is the divisor. It performs the following steps when called:

1. If x is NaN or y is NaN , return NaN .
2. If x is either +∞ _𝔽 or -∞ _𝔽, then
   1. If y is either +∞ _𝔽 or -∞ _𝔽, return NaN .
   2. If y is +0 _𝔽 or y > +0 _𝔽, return x.
   3. Return -x.
3. If y is +∞ _𝔽, then
   1. If x is +0 _𝔽 or x > +0 _𝔽, return +0 _𝔽. Otherwise, return -0 _𝔽.
4. If y is -∞ _𝔽, then
   1. If x is +0 _𝔽 or x > +0 _𝔽, return -0 _𝔽. Otherwise, return +0 _𝔽.
5. If x is either +0 _𝔽 or -0 _𝔽, then
   1. If y is either +0 _𝔽 or -0 _𝔽, return NaN .
   2. If y > +0 _𝔽, return x.
   3. Return -x.
6. If y is +0 _𝔽, then
   1. If x > +0 _𝔽, return +∞ _𝔽. Otherwise, return -∞ _𝔽.
7. If y is -0 _𝔽, then
   1. If x > +0 _𝔽, return -∞ _𝔽. Otherwise, return +∞ _𝔽.
8. Return 𝔽 ( ℝ (x) / ℝ (y)).

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:

1. If n is NaN or d is NaN , return NaN .
2. If n is either +∞ _𝔽 or -∞ _𝔽, return NaN .
3. If d is either +∞ _𝔽 or -∞ _𝔽, return n.
4. If d is either +0 _𝔽 or -0 _𝔽, return NaN .
5. If n is either +0 _𝔽 or -0 _𝔽, return n.
6. Assert : n and d are finite and non-zero.
7. Let quotient be ℝ (n) / ℝ (d).
8. Let q be truncate (quotient).
9. Let r be ℝ (n) - ( ℝ (d) × q).
10. If r = 0 and n < -0 _𝔽, return -0 _𝔽.
11. Return 𝔽 (r).

In C and C++, the remainder operator accepts only integral operands; in ECMAScript, it also accepts floating-point operands.

The result of a floating-point remainder operation as computed by the

operator is not the same as the “remainder” operation defined by

. The

“remainder” operation computes the remainder from a rounding division, not a truncating division, and so its behaviour is not analogous to that of the usual

remainder operator. Instead the ECMAScript language defines

on floating-point operations to behave in a manner analogous to that of the Java

remainder operator; this may be compared with the C library function fmod.

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 IEEE 754-2019 binary double-precision arithmetic, producing the sum of its arguments. It performs the following steps when called:

1. If x is NaN or y is NaN , return NaN .
2. If x is +∞ _𝔽 and y is -∞ _𝔽, return NaN .
3. If x is -∞ _𝔽 and y is +∞ _𝔽, return NaN .
4. If x is either +∞ _𝔽 or -∞ _𝔽, return x.
5. If y is either +∞ _𝔽 or -∞ _𝔽, return y.
6. Assert : x and y are both finite .
7. If x is -0 _𝔽 and y is -0 _𝔽, return -0 _𝔽.
8. Return 𝔽 ( ℝ (x) + ℝ (y)).

Finite -precision addition is commutative, but not always associative.

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:

1. Return Number::add (x, Number::unaryMinus (y)).

It is always the case that x - y produces the same result as x + (-y).

The abstract operation Number::leftShift takes arguments x (a Number) and y (a Number) and returns an integral Number . It performs the following steps when called:

1. Let lNum be !  ToInt32 (x).
2. Let rNum be !  ToUint32 (y).
3. Let shiftCount be ℝ (rNum) modulo 32.
4. Return the result of left shifting lNum by shiftCount bits. The mathematical value of the result is exactly representable as a 32-bit two's complement bit string.

The abstract operation Number::signedRightShift takes arguments x (a Number) and y (a Number) and returns an integral Number . It performs the following steps when called:

1. Let lNum be !  ToInt32 (x).
2. Let rNum be !  ToUint32 (y).
3. Let shiftCount be ℝ (rNum) modulo 32.
4. Return the result of performing a sign-extending right shift of lNum by shiftCount bits. The most significant bit is propagated. The mathematical value of the result is exactly representable as a 32-bit two's complement bit string.

The abstract operation Number::unsignedRightShift takes arguments x (a Number) and y (a Number) and returns an integral Number . It performs the following steps when called:

1. Let lNum be !  ToUint32 (x).
2. Let rNum be !  ToUint32 (y).
3. Let shiftCount be ℝ (rNum) modulo 32.
4. Return the result of performing a zero-filling right shift of lNum by shiftCount bits. Vacated bits are filled with zero. The mathematical value of the result is exactly representable as a 32-bit unsigned bit string.

The abstract operation Number::lessThan takes arguments x (a Number) and y (a Number) and returns a Boolean or undefined . It performs the following steps when called:

1. If x is NaN , return undefined .
2. If y is NaN , return undefined .
3. If x is y, return false .
4. If x is +0 _𝔽 and y is -0 _𝔽, return false .
5. If x is -0 _𝔽 and y is +0 _𝔽, return false .
6. If x is +∞ _𝔽, return false .
7. If y is +∞ _𝔽, return true .
8. If y is -∞ _𝔽, return false .
9. If x is -∞ _𝔽, return true .
10. Assert : x and y are finite .
11. If ℝ (x) < ℝ (y), return true . Otherwise, return false .

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:

1. If x is NaN , return false .
2. If y is NaN , return false .
3. If x is y, return true .
4. If x is +0 _𝔽 and y is -0 _𝔽, return true .
5. If x is -0 _𝔽 and y is +0 _𝔽, return true .
6. Return false .

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:

1. If x is NaN and y is NaN , return true .
2. If x is +0 _𝔽 and y is -0 _𝔽, return false .
3. If x is -0 _𝔽 and y is +0 _𝔽, return false .
4. If x is y, return true .
5. Return false .

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:

1. If x is NaN and y is NaN , return true .
2. If x is +0 _𝔽 and y is -0 _𝔽, return true .
3. If x is -0 _𝔽 and y is +0 _𝔽, return true .
4. If x is y, return true .
5. Return false .

The abstract operation NumberBitwiseOp takes arguments op (&, ^, or |), x (a Number), and y (a Number) and returns an integral Number . It performs the following steps when called:

1. Let lNum be !  ToInt32 (x).
2. Let rNum be !  ToInt32 (y).
3. Let lBits be the 32-bit two's complement bit string representing ℝ (lNum).
4. Let rBits be the 32-bit two's complement bit string representing ℝ (rNum).
5. If op is &, then
   1. Let result be the result of applying the bitwise AND operation to lBits and rBits.
6. Else if op is ^, then
   1. Let result be the result of applying the bitwise exclusive OR (XOR) operation to lBits and rBits.
7. Else,
   1. Assert : op is |.
   2. Let result be the result of applying the bitwise inclusive OR operation to lBits and rBits.
8. Return the Number value for the integer represented by the 32-bit two's complement bit string result.

The abstract operation Number::bitwiseAND takes arguments x (a Number) and y (a Number) and returns an integral Number . It performs the following steps when called:

1. Return NumberBitwiseOp (&, x, y).

The abstract operation Number::bitwiseXOR takes arguments x (a Number) and y (a Number) and returns an integral Number . It performs the following steps when called:

1. Return NumberBitwiseOp (^, x, y).

The abstract operation Number::bitwiseOR takes arguments x (a Number) and y (a Number) and returns an integral Number . It performs the following steps when called:

1. Return NumberBitwiseOp (|, x, y).

The abstract operation Number::toString takes arguments x (a Number) and radix (an integer in the inclusive interval from 2 to 36) and returns a String. It represents x as a String using a positional numeral system with radix radix. The digits used in the representation of a number using radix r are taken from the first r code units of "0123456789abcdefghijklmnopqrstuvwxyz" in order. The representation of numbers with magnitude greater than or equal to 1 _𝔽 never includes leading zeroes. It performs the following steps when called:

1. If x is NaN , return "NaN" .
2. If x is either +0 _𝔽 or -0 _𝔽, return "0" .
3. If x < -0 _𝔽, return the string-concatenation of "-" and Number::toString (-x, radix).
4. If x is +∞ _𝔽, return "Infinity" .
5. 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.
6. If radix ≠ 10 or n is in the inclusive interval from -5 to 21, then
   1. If n ≥ k, then
      1. Return the string-concatenation 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)
   2. Else if n > 0, then
      1. Return the string-concatenation 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
   3. Else,
      1. Assert : n ≤ 0.
      2. Return the string-concatenation 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
7. NOTE: In this case, the input will be represented using scientific E notation, such as 1.2e+3.
8. Assert : radix is 10.
9. If n < 0, then
   1. Let exponentSign be the code unit 0x002D (HYPHEN-MINUS).
10. Else,
    1. Let exponentSign be the code unit 0x002B (PLUS SIGN).
11. If k = 1, then
    1. Return the string-concatenation 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)
12. Return the string-concatenation 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:

• If x is any Number value other than -0 _𝔽, then ToNumber ( ToString (x)) is 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 5 be used as a guideline:

1. 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 binary-to-decimal conversion of floating-point numbers:

Gay, David M. Correctly Rounded Binary-Decimal and Decimal-Binary Conversions. Numerical Analysis, Manuscript 90-10. AT&T Bell Laboratories (Murray Hill, New Jersey). 30 November 1990. Available as
https://ampl.com/_archive/first-website/REFS/rounding.pdf. 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.

The BigInt type represents an integer value. The value may be any size and is not limited to a particular bit-width. Generally, where not otherwise noted, operations are designed to return exact mathematically-based answers. For binary operations, BigInts act as two's complement binary strings, with negative numbers treated as having bits set infinitely to the left.

The abstract operation BigInt::unaryMinus takes argument x (a BigInt) and returns a BigInt. It performs the following steps when called:

1. If x = 0 _ℤ, return 0 _ℤ.
2. Return -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:

1. Return -x - 1 _ℤ.

The abstract operation BigInt::exponentiate takes arguments base (a BigInt) and exponent (a BigInt) and returns either a normal completion containing a BigInt or a throw completion . It performs the following steps when called:

1. If exponent < 0 _ℤ, throw a RangeError exception.
2. If base = 0 _ℤ and exponent = 0 _ℤ, return 1 _ℤ.
3. Return base raised to the power exponent.

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:

1. Return x × y.

Even if the result has a much larger bit width than the input, the exact mathematical answer is given.

The abstract operation BigInt::divide takes arguments x (a BigInt) and y (a BigInt) and returns either a normal completion containing a BigInt or a throw completion . It performs the following steps when called:

1. If y = 0 _ℤ, throw a RangeError exception.
2. Let quotient be ℝ (x) / ℝ (y).
3. Return ℤ ( truncate (quotient)).

The abstract operation BigInt::remainder takes arguments n (a BigInt) and d (a BigInt) and returns either a normal completion containing a BigInt or a throw completion . It performs the following steps when called:

1. If d = 0 _ℤ, throw a RangeError exception.
2. If n = 0 _ℤ, return 0 _ℤ.
3. Let quotient be ℝ (n) / ℝ (d).
4. Let q be ℤ ( truncate (quotient)).
5. Return n - (d × q).

The sign of the result is the sign of the dividend.

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:

1. Return 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:

1. Return 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:

1. If y < 0 _ℤ, then
   1. Return ℤ ( floor ( ℝ (x) / 2^{- ℝ (y)})).
2. Return x × 2 _ℤ^y.

Semantics here should be equivalent to a bitwise shift, treating the BigInt as an infinite length string of binary two's complement digits.

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:

1. Return BigInt::leftShift (x, -y).

The abstract operation BigInt::unsignedRightShift takes arguments x (a BigInt) and y (a BigInt) and returns a throw completion . It performs the following steps when called:

1. Throw a TypeError exception.

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:

1. If ℝ (x) < ℝ (y), return true ; otherwise return false .

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:

1. If ℝ (x) = ℝ (y), return true ; otherwise return false .

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:

1. If x = 1 and y = 1, return 1.
2. Else, return 0.

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:

1. If x = 1 or y = 1, return 1.
2. Else, return 0.

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:

1. If x = 1 and y = 0, return 1.
2. Else if x = 0 and y = 1, return 1.
3. Else, return 0.

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:

1. Set x to ℝ (x).
2. Set y to ℝ (y).
3. Let result be 0.
4. Let shift be 0.
5. Repeat, until (x = 0 or x = -1) and (y = 0 or y = -1),
   1. Let xDigit be x modulo 2.
   2. Let yDigit be y modulo 2.
   3. If op is &, then
      1. Set result to result + 2^shift × BinaryAnd (xDigit, yDigit).
   4. Else if op is |, then
      1. Set result to result + 2^shift × BinaryOr (xDigit, yDigit).
   5. Else,
      1. Assert : op is ^.
      2. Set result to result + 2^shift × BinaryXor (xDigit, yDigit).
   6. Set shift to shift + 1.
   7. Set x to (x - xDigit) / 2.
   8. Set y to (y - yDigit) / 2.
6. If op is &, then
   1. Let tmp be BinaryAnd (x modulo 2, y modulo 2).
7. Else if op is |, then
   1. Let tmp be BinaryOr (x modulo 2, y modulo 2).
8. Else,
   1. Assert : op is ^.
   2. Let tmp be BinaryXor (x modulo 2, y modulo 2).
9. If tmp ≠ 0, then
   1. Set result to result - 2^shift.
   2. NOTE: This extends the sign.
10. Return the BigInt value for result.

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:

1. Return BigIntBitwiseOp (&, 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:

1. Return BigIntBitwiseOp (^, 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:

1. Return BigIntBitwiseOp (|, x, y).

The abstract operation BigInt::toString takes arguments x (a BigInt) and radix (an integer in the inclusive interval from 2 to 36) and returns a String. It represents x as a String using a positional numeral system with radix radix. The digits used in the representation of a BigInt using radix r are taken from the first r code units of "0123456789abcdefghijklmnopqrstuvwxyz" in order. The representation of BigInts other than 0 _ℤ never includes leading zeroes. It performs the following steps when called:

1. If x < 0 _ℤ, return the string-concatenation of "-" and BigInt::toString (-x, radix).
2. Return the String value consisting of the representation of x using radix radix.

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 is a String .

An integer index is a property name n such that CanonicalNumericIndexString (n) returns an integral Number in the inclusive interval from +0 _𝔽 to 𝔽 (2⁵³ - 1). An array index is an integer index n such that CanonicalNumericIndexString (n) returns an integral Number in the inclusive interval from +0 _𝔽 to 𝔽 (2³² - 2).

Every non-negative safe integer has a corresponding integer index . Every 32-bit unsigned integer except 2 ³² - 1 has a corresponding array index . "-0" is neither an integer index nor an array index .

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.2 for definitions of the multiple forms of objects.

In addition, some objects are callable; these are referred to as functions or function objects and are described further below. All functions in ECMAScript are members of the Object type.

Attributes are used in this specification to define and explain the state of Object properties as described in Table 3 . Unless specified explicitly, the initial value of each attribute is its Default Value.

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

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

Internal slots correspond to internal state that is associated with objects and used by various ECMAScript specification algorithms. Internal slots are not object properties and they are not inherited. Depending upon the specific internal slot specification, such state may consist of values of any ECMAScript language type or of specific ECMAScript specification type values. Unless explicitly specified otherwise, internal slots are allocated as part of the process of creating an object and may not be dynamically added to an object. Unless specified otherwise, the initial value of an internal slot is the value undefined . Various algorithms within this specification create objects that have internal slots. However, the ECMAScript language provides no direct way to associate internal slots with an object.

All objects have an internal slot named [[PrivateElements]], which is a List of PrivateElements . This List represents the values of the private fields, methods, and accessors for the object. Initially, it is an empty List .

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

Table 4 summarizes the essential internal methods used by this specification that are applicable to all objects created or manipulated by ECMAScript code. Every object must have algorithms for all of the essential internal methods. However, all objects do not necessarily use the same algorithms for those methods.

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 in 10.1 .
• If the object has a [[Call]] internal method, it uses either the one defined in 10.2.1 or the one defined in 10.3.1 .
• If the object has a [[Construct]] internal method, it uses either the one defined in 10.2.2 or the one defined in 10.3.2 .

An exotic object is an object that is not an ordinary object .

This specification recognizes different kinds of exotic objects by those objects' internal methods. An object that is behaviourally equivalent to a particular kind of exotic object (such as an Array exotic object or a bound function exotic object ), but does not have the same collection of internal methods specified for that kind, is not recognized as that kind of exotic object .

The “Signature” column of Table 4 and other similar tables describes the invocation pattern for each internal method. The invocation pattern always includes a parenthesized list of descriptive parameter names. If a parameter name is the same as an ECMAScript type name then the name describes the required type of the parameter value. If an internal method explicitly returns a value, its parameter list is followed by the symbol “→” and the type name of the returned value. The type names used in signatures refer to the types defined in clause 6 augmented by the following additional names. “any” means the value may be any ECMAScript language type .

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

An internal method implicitly returns a Completion Record , either a normal completion that wraps a value of the return type shown in its invocation pattern, or a throw completion .

Table 5 summarizes additional essential internal methods that are supported by objects that may be called as functions. A function object is an object that supports the [[Call]] internal method. A constructor is an object that supports the [[Construct]] internal method. Every object that supports [[Construct]] must support [[Call]]; that is, every constructor must be a function object . Therefore, a constructor may also be referred to as a constructor function or constructor function object .

The semantics of the essential internal methods for ordinary objects and standard exotic objects are specified in clause 10 . If any specified use of an internal method of an exotic object is not supported by an implementation, that usage must throw a TypeError exception when attempted.

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

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

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

• The target of an internal method is the object upon which the internal method is called.
• A target is non-extensible if it has been observed to return false from its [[IsExtensible]] internal method, or true from its [[PreventExtensions]] internal method.
• A non-existent property is a property that does not exist as an own property on a non-extensible target.
• All references to SameValue are according to the definition of the SameValue algorithm.

The value returned by any internal method must be a Completion Record with either:

• [[Type]] = normal , [[Target]] = empty , and [[Value]] = a value of the "normal return type" shown below for that internal method, or
• [[Type]] = throw , [[Target]] = empty , and [[Value]] = any ECMAScript language value .

An internal method must not return a continue completion , a break completion , or a return completion .

• The normal return type is either Object or Null.
• If target is non-extensible, 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 null ). However, this requirement is not enforceable as an object level invariant if the prototype chain includes any exotic objects that do not use the ordinary object definition of [[GetPrototypeOf]]. Such a circular prototype chain may result in infinite loops when accessing object properties.

• The normal return type is Boolean.
• If target is non-extensible, [[SetPrototypeOf]] must return false , unless V is the SameValue as the target's observed [[GetPrototypeOf]] value.

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

• The normal return type is Boolean.
• If [[PreventExtensions]] returns true , all future calls to [[IsExtensible]] on the target must return false and the target is now considered non-extensible.

• The normal return type is either Property Descriptor or Undefined.
• If the return value is a Property Descriptor , it must be a fully populated Property Descriptor .
• If P is described as a non-configurable, non-writable own data property , all future calls to [[GetOwnProperty]] ( P ) must return Property Descriptor whose [[Value]] is SameValue as P's [[Value]] attribute.
• If P's attributes other than [[Writable]] and [[Value]] 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 to true , then the [[Configurable]] attribute must be true .
• If the target is non-extensible and P is non-existent, then all future calls to [[GetOwnProperty]] (P) on the target must describe P as non-existent (i.e. [[GetOwnProperty]] (P) must return undefined ).

As a consequence of the third invariant, if a property is described as a data property and it may return different values over time, then either or both of the [[Writable]] and [[Configurable]] attributes must be true even if no mechanism to change the value is exposed via the other essential internal methods.

• The normal return type is Boolean.
• [[DefineOwnProperty]] must return false if P has previously been observed as a non-configurable own property of the target, unless either:
  1. P is a writable data property . A non-configurable writable data property can be changed into a non-configurable non-writable data property .
  2. All attributes of Desc are the SameValue as P's attributes.
• [[DefineOwnProperty]] (P, Desc) must return false if target is non-extensible and P is a non-existent own property. That is, a non-extensible target object cannot be extended with new properties.

• The normal return type is Boolean.
• If P was previously observed as a non-configurable own data or accessor property of the target, [[HasProperty]] must return true .

• The normal return type is any ECMAScript language type .
• If P was previously observed as a non-configurable, non-writable own data property of the target with value V, then [[Get]] must return the SameValue as V.
• If P was previously observed as a non-configurable own accessor property of the target whose [[Get]] attribute is undefined , the [[Get]] operation must return undefined .

• The normal return type is Boolean.
• If P was previously observed as a non-configurable, non-writable own data property of the target, then [[Set]] must return false unless V is the SameValue as P's [[Value]] attribute.
• If P was previously observed as a non-configurable own accessor property of the target whose [[Set]] attribute is undefined , the [[Set]] operation must return false .

• The normal return type is Boolean.
• If P was previously observed as a non-configurable own data or accessor property of the target, [[Delete]] must return false .

• The normal return type is List .
• The returned List must not contain any duplicate entries.
• Each element of the returned List must be a property key .
• The returned List must contain at least the keys of all non-configurable own properties that have previously been observed.
• If the target is non-extensible, the returned List must contain only the keys of all own properties of the target that are observable using [[GetOwnProperty]].

• The normal return type is any ECMAScript language type .

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

Well-known intrinsics are built-in objects that are explicitly referenced by the algorithms of this specification and which usually have realm -specific identities. Unless otherwise specified each intrinsic object actually corresponds to a set of similar objects, one per realm .

Within this specification a reference such as %name% means the intrinsic object, associated with the current realm , corresponding to the name. A reference such as %name.a.b% means, as if the "b" property of the value of the "a" property of the intrinsic object %name% was accessed prior to any ECMAScript code being evaluated. Determination of the current realm and its intrinsics is described in 9.4 . The well-known intrinsics are listed in Table 6 .

Additional entries in Table 102 .

A specification type corresponds to meta-values that are used within algorithms to describe the semantics of ECMAScript language constructs and ECMAScript language types . The specification types include Reference Record , List , Completion Record , Property Descriptor , Environment Record , Abstract Closure , and Data Block . Specification type values are specification artefacts that do not necessarily correspond to any specific entity within an ECMAScript implementation. Specification type values may be used to describe intermediate results of ECMAScript expression evaluation but such values cannot be stored as properties of objects or values of ECMAScript language variables.

Enums are values which are internal to the specification and not directly observable from ECMAScript code. Enums are denoted using a sans-serif typeface. For instance, a Completion Record 's [[Type]] field takes on values like normal , return , or throw . Enums have no characteristics other than their name. The name of an enum serves no purpose other than to distinguish it from other enums, and implies nothing about its usage or meaning in context.

The List type is used to explain the evaluation of argument lists (see 13.3.8 ) in new expressions, in function calls, and in other algorithms where a simple ordered list of values is needed. Values of the List type are simply ordered sequences of list elements containing the individual values. These sequences may be of any length. The elements of a list may be randomly accessed using 0-origin indices. For notational convenience an array-like syntax can be used to access List elements. For example, arguments[2] is shorthand for saying the 3^rd element of the List arguments.

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

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

In this specification, the phrase "the list-concatenation of A, B, ..." (where each argument is a possibly empty List) denotes a new List value whose elements are the concatenation of the elements (in order) of each of the arguments (in order).

As applied to a List of Strings, the phrase "sorted according to lexicographic code unit order" means sorting by the numeric value of each code unit up to the length of the shorter string, and sorting the shorter string before the longer string if all are equal, as described in the abstract operation IsLessThan .

The Record type is used to describe data aggregations within the algorithms of this specification. A Record type value consists of one or more named fields. The value of each field is an ECMAScript language value or specification value. Field names are always enclosed in double brackets, for example [[Value]].

For notational convenience within this specification, an object literal-like syntax can be used to express a Record value. For example, { [[Field1]]: 42, [[Field2]]: false , [[Field3]]: empty } defines a Record value that has three fields, each of which is initialized to a specific value. Field name order is not significant. Any fields that are not explicitly listed are considered to be absent.

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

Schema for commonly used Record field combinations may be named, and that name may be used as a prefix to a literal Record value to identify the specific kind of aggregations that is being described. For example: PropertyDescriptor { [[Value]]: 42, [[Writable]]: false , [[Configurable]]: true }.

The Set type is used to explain a collection of unordered elements for use in the memory model . It is distinct from the ECMAScript collection type of the same name. To disambiguate, instances of the ECMAScript collection are consistently referred to as "Set objects" within this specification. Values of the Set type are simple collections of elements, where no element appears more than once. Elements may be added to and removed from Sets. Sets may be unioned, intersected, or subtracted from each other.

The Relation type is used to explain constraints on Sets. Values of the Relation type are Sets of ordered pairs of values from its value domain. For example, a Relation on events is a set of ordered pairs of events. For a Relation R and two values a and b in the value domain of R, a R b is shorthand for saying the ordered pair (a, b) is a member of R. A Relation is the least Relation with respect to some conditions when it is the smallest Relation that satisfies those conditions.

A strict partial order is a Relation value R that satisfies the following.

• For all a, b, and c in R's domain:

  • It is not the case that a R a, and
  • If a R b and b R c, then a R c.

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

A strict total order is a Relation value R that satisfies the following.

• For all a, b, and c in R's domain:

  • a is b or a R b or b R a, and
  • It is not the case that a R a, and
  • If a R b and b R c, then a R c.

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

The Completion Record specification type is used to explain the runtime propagation of values and control flow such as the behaviour of statements (break, continue, return and throw) that perform nonlocal transfers of control.

Completion Records have the fields defined in Table 7 .

The following shorthand terms are sometimes used to refer to Completion Records.

• normal completion refers to any Completion Record with a [[Type]] value of normal .
• break completion refers to any Completion Record with a [[Type]] value of break .
• continue completion refers to any Completion Record with a [[Type]] value of continue .
• return completion refers to any Completion Record with a [[Type]] value of return .
• throw completion refers to any Completion Record with a [[Type]] value of throw .
• abrupt completion refers to any Completion Record with a [[Type]] value other than normal .
• a normal completion containing some type of value refers to a normal completion that has a value of that type in its [[Value]] field.

Callable objects that are defined in this specification only return a normal completion or a throw completion. Returning any other kind of Completion Record is considered an editorial error.

Implementation-defined callable objects must return either a normal completion or a throw completion.

The abstract operation NormalCompletion takes argument value (any value except a Completion Record ) and returns a normal completion . It performs the following steps when called:

1. Return Completion Record { [[Type]]: normal , [[Value]]: value, [[Target]]: empty  }.

The abstract operation ThrowCompletion takes argument value (an ECMAScript language value ) and returns a throw completion . It performs the following steps when called:

1. Return Completion Record { [[Type]]: throw , [[Value]]: value, [[Target]]: empty  }.

The abstract operation ReturnCompletion takes argument value (an ECMAScript language value ) and returns a return completion . It performs the following steps when called:

1. Return Completion Record { [[Type]]: return , [[Value]]: value, [[Target]]: empty  }.

The abstract operation UpdateEmpty takes arguments completionRecord (a Completion Record ) and value (any value except a Completion Record ) and returns a Completion Record . It performs the following steps when called:

1. Assert : If completionRecord is either a return completion or a throw completion , then completionRecord.[[Value]] is not empty .
2. If completionRecord.[[Value]] is not empty , return ? completionRecord.
3. Return Completion Record { [[Type]]: completionRecord.[[Type]], [[Value]]: value, [[Target]]: completionRecord.[[Target]] }.

The Reference Record type is used to explain the behaviour of such operators as delete, typeof, the assignment operators, the super keyword and other language features. For example, the left-hand operand of an assignment is expected to produce a Reference Record.

A Reference Record is a resolved name or (possibly not-yet-resolved) property binding; its fields are defined by Table 8 .

The following abstract operations are used in this specification to operate upon Reference Records:

The abstract operation IsPropertyReference takes argument V (a Reference Record ) and returns a Boolean. It performs the following steps when called:

1. If V.[[Base]] is unresolvable , return false .
2. If V.[[Base]] is an Environment Record , return false ; otherwise return true .

The abstract operation IsUnresolvableReference takes argument V (a Reference Record ) and returns a Boolean. It performs the following steps when called:

1. If V.[[Base]] is unresolvable , return true ; otherwise return false .

The abstract operation IsSuperReference takes argument V (a Reference Record ) and returns a Boolean. It performs the following steps when called:

1. If V.[[ThisValue]] is not empty , return true ; otherwise return false .

The abstract operation IsPrivateReference takes argument V (a Reference Record ) and returns a Boolean. It performs the following steps when called:

1. If V.[[ReferencedName]] is a Private Name , return true ; otherwise return false .

The abstract operation GetValue takes argument V (a Reference Record or an ECMAScript language value ) and returns either a normal completion containing an ECMAScript language value or an abrupt completion . It performs the following steps when called:

1. If V is not a Reference Record , return V.
2. If IsUnresolvableReference (V) is true , throw a ReferenceError exception.
3. If IsPropertyReference (V) is true , then
   1. Let baseObj be ?  ToObject (V.[[Base]]).
   2. If IsPrivateReference (V) is true , then
      1. Return ?  PrivateGet (baseObj, V.[[ReferencedName]]).
   3. If V.[[ReferencedName]] is not a property key , then
      1. Set V.[[ReferencedName]] to ?  ToPropertyKey (V.[[ReferencedName]]).
   4. Return ? baseObj.[[Get]](V.[[ReferencedName]], GetThisValue (V)).
4. Else,
   1. Let base be V.[[Base]].
   2. Assert : base is an Environment Record .
   3. Return ? base.GetBindingValue(V.[[ReferencedName]], V.[[Strict]]) (see 9.1 ).

The object that may be created in step 3.a is not accessible outside of the above abstract operation and the ordinary object [[Get]] internal method. An implementation might choose to avoid the actual creation of the object.

The abstract operation PutValue takes arguments V (a Reference Record or an ECMAScript language value ) and W (an ECMAScript language value ) and returns either a normal completion containing unused or an abrupt completion . It performs the following steps when called:

1. If V is not a Reference Record , throw a ReferenceError exception.
2. If IsUnresolvableReference (V) is true , then
   1. If V.[[Strict]] is true , throw a ReferenceError exception.
   2. Let globalObj be GetGlobalObject ().
   3. Perform ?  Set (globalObj, V.[[ReferencedName]], W, false ).
   4. Return unused .
3. If IsPropertyReference (V) is true , then
   1. Let baseObj be ?  ToObject (V.[[Base]]).
   2. If IsPrivateReference (V) is true , then
      1. Return ?  PrivateSet (baseObj, V.[[ReferencedName]], W).
   3. If V.[[ReferencedName]] is not a property key , then
      1. Set V.[[ReferencedName]] to ?  ToPropertyKey (V.[[ReferencedName]]).
   4. Let succeeded be ? baseObj.[[Set]](V.[[ReferencedName]], W, GetThisValue (V)).
   5. If succeeded is false and V.[[Strict]] is true , throw a TypeError exception.
   6. Return unused .
4. Else,
   1. Let base be V.[[Base]].
   2. Assert : base is an Environment Record .
   3. Return ? base.SetMutableBinding(V.[[ReferencedName]], W, V.[[Strict]]) (see 9.1 ).

The object that may be created in step 3.a is not accessible outside of the above abstract operation and the ordinary object [[Set]] internal method. An implementation might choose to avoid the actual creation of that object.

The abstract operation GetThisValue takes argument V (a Reference Record ) and returns an ECMAScript language value . It performs the following steps when called:

1. Assert : IsPropertyReference (V) is true .
2. If IsSuperReference (V) is true , return V.[[ThisValue]]; otherwise return V.[[Base]].

The abstract operation InitializeReferencedBinding takes arguments V (a Reference Record ) and W (an ECMAScript language value ) and returns either a normal completion containing unused or an abrupt completion . It performs the following steps when called:

1. Assert : IsUnresolvableReference (V) is false .
2. Let base be V.[[Base]].
3. Assert : base is an Environment Record .
4. Return ? base.InitializeBinding(V.[[ReferencedName]], W).

The abstract operation MakePrivateReference takes arguments baseValue (an ECMAScript language value ) and privateIdentifier (a String) and returns a Reference Record . It performs the following steps when called:

1. Let privateEnv be the running execution context 's PrivateEnvironment.
2. Assert : privateEnv is not null .
3. Let privateName be ResolvePrivateIdentifier (privateEnv, privateIdentifier).
4. Return the Reference Record { [[Base]]: baseValue, [[ReferencedName]]: privateName, [[Strict]]: true , [[ThisValue]]: empty  }.

The Property Descriptor type is used to explain the manipulation and reification of Object property attributes. A Property Descriptor is a Record with zero or more fields, where each field's name is an attribute name and its value is a corresponding attribute value as specified in 6.1.7.1 . The schema name used within this specification to tag literal descriptions of Property Descriptor records is “PropertyDescriptor”.

Property Descriptor values may be further classified as data Property Descriptors and accessor Property Descriptors based upon the existence or use of certain fields. A data Property Descriptor is one that includes any fields named either [[Value]] or [[Writable]]. An accessor Property Descriptor is one that includes any fields named either [[Get]] or [[Set]]. Any Property Descriptor may have fields named [[Enumerable]] and [[Configurable]]. A Property Descriptor value may not be both a data Property Descriptor and an accessor Property Descriptor; however, it may be neither (in which case it is a generic Property Descriptor). A fully populated Property Descriptor is one that is either an accessor Property Descriptor or a data Property Descriptor and that has all of the corresponding fields defined in Table 3 .

The following abstract operations are used in this specification to operate upon Property Descriptor values:

The abstract operation IsAccessorDescriptor takes argument Desc (a Property Descriptor ) and returns a Boolean. It performs the following steps when called:

1. If Desc has a [[Get]] field, return true .
2. If Desc has a [[Set]] field, return true .
3. Return false .

The abstract operation IsDataDescriptor takes argument Desc (a Property Descriptor ) and returns a Boolean. It performs the following steps when called:

1. If Desc has a [[Value]] field, return true .
2. If Desc has a [[Writable]] field, return true .
3. Return false .

The abstract operation IsGenericDescriptor takes argument Desc (a Property Descriptor ) and returns a Boolean. It performs the following steps when called:

1. If IsAccessorDescriptor (Desc) is true , return false .
2. If IsDataDescriptor (Desc) is true , return false .
3. Return true .

The abstract operation FromPropertyDescriptor takes argument Desc (a Property Descriptor or undefined ) and returns an Object or undefined . It performs the following steps when called:

1. If Desc is undefined , return undefined .
2. Let obj be OrdinaryObjectCreate ( %Object.prototype% ).
3. Assert : obj is an extensible ordinary object with no own properties.
4. If Desc has a [[Value]] field, then
   1. Perform !  CreateDataPropertyOrThrow (obj, "value" , Desc.[[Value]]).
5. If Desc has a [[Writable]] field, then
   1. Perform !  CreateDataPropertyOrThrow (obj, "writable" , Desc.[[Writable]]).
6. If Desc has a [[Get]] field, then
   1. Perform !  CreateDataPropertyOrThrow (obj, "get" , Desc.[[Get]]).
7. If Desc has a [[Set]] field, then
   1. Perform !  CreateDataPropertyOrThrow (obj, "set" , Desc.[[Set]]).
8. If Desc has an [[Enumerable]] field, then
   1. Perform !  CreateDataPropertyOrThrow (obj, "enumerable" , Desc.[[Enumerable]]).
9. If Desc has a [[Configurable]] field, then
   1. Perform !  CreateDataPropertyOrThrow (obj, "configurable" , Desc.[[Configurable]]).
10. Return obj.

The abstract operation ToPropertyDescriptor takes argument Obj (an ECMAScript language value ) and returns either a normal completion containing a Property Descriptor or a throw completion . It performs the following steps when called:

1. If Obj is not an Object , throw a TypeError exception.
2. Let desc be a new Property Descriptor that initially has no fields.
3. Let hasEnumerable be ?  HasProperty (Obj, "enumerable" ).
4. If hasEnumerable is true , then
   1. Let enumerable be ToBoolean (? Get (Obj, "enumerable" )).
   2. Set desc.[[Enumerable]] to enumerable.
5. Let hasConfigurable be ?  HasProperty (Obj, "configurable" ).
6. If hasConfigurable is true , then
   1. Let configurable be ToBoolean (? Get (Obj, "configurable" )).
   2. Set desc.[[Configurable]] to configurable.
7. Let hasValue be ?  HasProperty (Obj, "value" ).
8. If hasValue is true , then
   1. Let value be ?  Get (Obj, "value" ).
   2. Set desc.[[Value]] to value.
9. Let hasWritable be ?  HasProperty (Obj, "writable" ).
10. If hasWritable is true , then
    1. Let writable be ToBoolean (? Get (Obj, "writable" )).
    2. Set desc.[[Writable]] to writable.
11. Let hasGet be ?  HasProperty (Obj, "get" ).
12. If hasGet is true , then
    1. Let getter be ?  Get (Obj, "get" ).
    2. If IsCallable (getter) is false and getter is not undefined , throw a TypeError exception.
    3. Set desc.[[Get]] to getter.
13. Let hasSet be ?  HasProperty (Obj, "set" ).
14. If hasSet is true , then
    1. Let setter be ?  Get (Obj, "set" ).
    2. If IsCallable (setter) is false and setter is not undefined , throw a TypeError exception.
    3. Set desc.[[Set]] to setter.
15. If desc has a [[Get]] field or desc has a [[Set]] field, then
    1. If desc has a [[Value]] field or desc has a [[Writable]] field, throw a TypeError exception.
16. Return desc.

The abstract operation CompletePropertyDescriptor takes argument Desc (a Property Descriptor ) and returns unused . It performs the following steps when called:

1. Let like be the Record { [[Value]]: undefined , [[Writable]]: false , [[Get]]: undefined , [[Set]]: undefined , [[Enumerable]]: false , [[Configurable]]: false  }.
2. If IsGenericDescriptor (Desc) is true or IsDataDescriptor (Desc) is true , then
   1. If Desc does not have a [[Value]] field, set Desc.[[Value]] to like.[[Value]].
   2. If Desc does not have a [[Writable]] field, set Desc.[[Writable]] to like.[[Writable]].
3. Else,
   1. If Desc does not have a [[Get]] field, set Desc.[[Get]] to like.[[Get]].
   2. If Desc does not have a [[Set]] field, set Desc.[[Set]] to like.[[Set]].
4. If Desc does not have an [[Enumerable]] field, set Desc.[[Enumerable]] to like.[[Enumerable]].
5. If Desc does not have a [[Configurable]] field, set Desc.[[Configurable]] to like.[[Configurable]].
6. Return unused .

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 Closures are meta-values and are invoked using function application style such as closure(arg1, arg2). Like abstract operations , 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 must be either a normal completion or a throw completion .

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 (x) that captures addend and performs the following steps when called:
   1. Return x + addend.
3. Let val be closure(1).
4. Assert : 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 integer in the inclusive interval from 0 to 255. 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 a Data Block value. This notation presents a Data Block value as a 0-based integer-indexed sequence of bytes. For example, if db is a 5 byte Data Block value then db[2] can be used to access its 3^rd 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.

The semantics of Shared Data Blocks is defined using Shared Data Block events by the memory model . Abstract operations below introduce Shared Data Block events and act as the interface between evaluation semantics and the event semantics of the memory model . The events form a candidate execution , on which the memory model acts as a filter. Please consult the memory model for full semantics.

Shared Data Block events are modelled by Records , defined in the memory model .

The following abstract operations are used in this specification to operate upon Data Block values:

The abstract operation CreateByteDataBlock takes argument size (a non-negative integer ) and returns either a normal completion containing a Data Block or a throw completion . It performs the following steps when called:

1. If size > 2⁵³ - 1, throw a RangeError exception.
2. Let db 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 db to 0.
4. Return db.

The abstract operation CopyDataBlockBytes takes arguments toBlock (a Data Block or a Shared Data Block ), toIndex (a non-negative integer ), fromBlock (a Data Block or a Shared Data Block ), fromIndex (a non-negative integer ), and count (a non-negative integer ) and returns unused . It performs the following steps when called:

1. Assert : fromBlock and toBlock are distinct values.
2. Let fromSize be the number of bytes in fromBlock.
3. Assert : fromIndex + count ≤ fromSize.
4. Let toSize be the number of bytes in toBlock.
5. Assert : toIndex + count ≤ toSize.
6. Repeat, while count > 0,
   1. If fromBlock is a Shared Data Block , then
      1. Let execution be the [[CandidateExecution]] field of the surrounding agent 's Agent Record .
      2. Let eventsRecord be the Agent Events Record of execution.[[EventsRecords]] whose [[AgentSignifier]] is AgentSignifier ().
      3. Let bytes be a List whose sole element is a nondeterministically chosen byte value .
      4. 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 memory model to describe observable behaviour of hardware with weak consistency.
      5. Let readEvent be ReadSharedMemory { [[Order]]: unordered , [[NoTear]]: true , [[Block]]: fromBlock, [[ByteIndex]]: fromIndex, [[ElementSize]]: 1 }.
      6. Append readEvent to eventsRecord.[[EventList]].
      7. Append Chosen Value Record { [[Event]]: readEvent, [[ChosenValue]]: bytes } to execution.[[ChosenValues]].
      8. If toBlock is a Shared Data Block , then
         1. Append WriteSharedMemory { [[Order]]: unordered , [[NoTear]]: true , [[Block]]: toBlock, [[ByteIndex]]: toIndex, [[ElementSize]]: 1, [[Payload]]: bytes } to eventsRecord.[[EventList]].
      9. Else,
         1. Set toBlock[toIndex] to bytes[0].
   2. Else,
      1. Assert : toBlock is not a Shared Data Block .
      2. Set toBlock[toIndex] to fromBlock[fromIndex].
   3. Set toIndex to toIndex + 1.
   4. Set fromIndex to fromIndex + 1.
   5. Set count to count - 1.
7. Return unused .

The PrivateElement type is a Record used in the specification of private class fields, methods, and accessors. Although Property Descriptors are not used for private elements, private fields behave similarly to non-configurable, non-enumerable, writable data properties , private methods behave similarly to non-configurable, non-enumerable, non-writable data properties , and private accessors behave similarly to non-configurable, non-enumerable accessor properties .

Values of the PrivateElement type are Record values whose fields are defined by Table 9 . Such values are referred to as PrivateElements.

The ClassFieldDefinition type is a Record used in the specification of class fields.

Values of the ClassFieldDefinition type are Record values whose fields are defined by Table 10 . Such values are referred to as ClassFieldDefinition Records.

The Private Name specification type is used to describe a globally unique value (one which differs from any other Private Name, even if they are otherwise indistinguishable) which represents the key of a private class element (field, method, or accessor). Each Private Name has an associated immutable [[Description]] which is a String value. A Private Name may be installed on any ECMAScript object with PrivateFieldAdd or PrivateMethodOrAccessorAdd , and then read or written using PrivateGet and PrivateSet .

A ClassStaticBlockDefinition Record is a Record value used to encapsulate the executable code for a class static initialization block.

ClassStaticBlockDefinition Records have the fields listed in Table 11 .

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.3