This function performs the following steps when called:

1. If value is present, then
   1. Let primitive be ? ToNumeric(value).
   2. If primitive is a BigInt, let n be 𝔽(ℝ(primitive)).
   3. Else, let n be primitive.
2. Else,
   1. Let n be +0_𝔽.
3. If NewTarget is undefined, return n.
4. Let obj be ? OrdinaryCreateFromConstructor(NewTarget, "%Number.prototype%", « [[NumberData]] »).
5. Set obj.[[NumberData]] to n.
6. Return obj.

The value of Number.EPSILON is the Number value for the magnitude of the difference between 1 and the smallest value greater than 1 that is representable as a Number value, which is approximately 2.2204460492503130808472633361816 × 10^-16.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

This function performs the following steps when called:

1. If number is not a Number, return false.
2. If number is not finite, return false.
3. Return true.

This function performs the following steps when called:

1. If number is an integral Number, return true.
2. Return false.

This function performs the following steps when called:

1. If number is not a Number, return false.
2. If number is NaN, return true.
3. Return false.

Note

This function differs from the global isNaN function (19.2.3) in that it does not convert its argument to a Number before determining whether it is NaN.

Note

An integer n is a “safe integer” if and only if the Number value for n is not the Number value for any other integer.

This function performs the following steps when called:

1. If number is an integral Number, then
   1. If abs(ℝ(number)) ≤ 2⁵³ - 1, return true.
2. Return false.

Note

Due to rounding behaviour necessitated by precision limitations of IEEE 754-2019, the Number value for every integer greater than Number.MAX_SAFE_INTEGER is shared with at least one other integer. Such large-magnitude integers are therefore not safe, and are not guaranteed to be exactly representable as Number values or even to be distinguishable from each other. For example, both 9007199254740992 and 9007199254740993 evaluate to the Number value 9007199254740992_𝔽.

The value of Number.MAX_SAFE_INTEGER is 9007199254740991_𝔽 (𝔽(2⁵³ - 1)).

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The value of Number.MAX_VALUE is the largest positive finite value of the Number type, which is approximately 1.7976931348623157 × 10³⁰⁸.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

Note

Due to rounding behaviour necessitated by precision limitations of IEEE 754-2019, the Number value for every integer less than Number.MIN_SAFE_INTEGER is shared with at least one other integer. Such large-magnitude integers are therefore not safe, and are not guaranteed to be exactly representable as Number values or even to be distinguishable from each other. For example, both -9007199254740992 and -9007199254740993 evaluate to the Number value -9007199254740992_𝔽.

The value of Number.MIN_SAFE_INTEGER is -9007199254740991_𝔽 (𝔽(-(2⁵³ - 1))).

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The value of Number.MIN_VALUE is the smallest positive value of the Number type, which is approximately 5 × 10^-324.

In the IEEE 754-2019 double precision binary representation, the smallest possible value is a denormalized number. If an implementation does not support denormalized values, the value of Number.MIN_VALUE must be the smallest non-zero positive value that can actually be represented by the implementation.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The value of Number.NaN is NaN.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The value of Number.NEGATIVE_INFINITY is -∞_𝔽.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The initial value of the "parseFloat" property is %parseFloat%.

The initial value of the "parseInt" property is %parseInt%.

The value of Number.POSITIVE_INFINITY is +∞_𝔽.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The initial value of Number.prototype is the Number prototype object.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The initial value of Number.prototype.constructor is %Number%.

This method returns a String containing this Number value represented in decimal exponential notation with one digit before the significand's decimal point and fractionDigits digits after the significand's decimal point. If fractionDigits is undefined, it includes as many significand digits as necessary to uniquely specify the Number (just like in ToString except that in this case the Number is always output in exponential notation).

It performs the following steps when called:

1. Let number be ? ThisNumberValue(this value).
2. Let fractionCount be ? ToIntegerOrInfinity(fractionDigits).
3. Assert: If fractionDigits is undefined, then fractionCount is 0.
4. If number is not finite, return Number::toString(number, 10).
5. If fractionCount < 0 or fractionCount > 100, throw a RangeError exception.
6. Set number to ℝ(number).
7. Let sign be the empty String.
8. If number < 0, then
   1. Set sign to "-".
   2. Set number to -number.
9. If number = 0, then
   1. Let significand be the String value consisting of fractionCount + 1 occurrences of the code unit 0x0030 (DIGIT ZERO).
   2. Let exponent be 0.
10. Else,
    1. If fractionDigits is not undefined, then
       1. Let exponent and intSignificand be integers such that 10^{fractionCount} ≤ intSignificand < 10^{fractionCount + 1} and for which intSignificand × 10^{exponent - fractionCount} - number is as close to zero as possible. If there are two such sets of exponent and intSignificand, pick the exponent and intSignificand for which intSignificand × 10^{exponent - fractionCount} is larger.
    2. Else,
       1. Let exponent, intSignificand, and ff be integers such that ff ≥ 0, 10^ff ≤ intSignificand < 10^{ff + 1}, 𝔽(intSignificand × 10^{exponent - ff}) is 𝔽(number), and ff is as small as possible. Note that the decimal representation of intSignificand has ff + 1 digits, intSignificand is not divisible by 10, and the least significant digit of intSignificand is not necessarily uniquely determined by these criteria.
       2. Set fractionCount to ff.
    3. Let significand be the String value consisting of the digits of the decimal representation of intSignificand (in order, with no leading zeroes).
11. If fractionCount ≠ 0, then
    1. Let intPart be the first code unit of significand.
    2. Let fractionalPart be the other fractionCount code units of significand.
    3. Set significand to the string-concatenation of intPart, ".", and fractionalPart.
12. If exponent = 0, then
    1. Let exponentSign be "+".
    2. Let exponentDigits be "0".
13. Else,
    1. If exponent > 0, then
       1. Let exponentSign be "+".
    2. Else,
       1. Assert: exponent < 0.
       2. Let exponentSign be "-".
       3. Set exponent to -exponent.
    3. Let exponentDigits be the String value consisting of the digits of the decimal representation of exponent (in order, with no leading zeroes).
14. Set significand to the string-concatenation of significand, "e", exponentSign, and exponentDigits.
15. Return the string-concatenation of sign and significand.

Note

For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step 10.b.i be used as a guideline:

1. Let exponent, intSignificand, and ff be integers such that ff ≥ 0, 10^ff ≤ intSignificand < 10^{ff + 1}, 𝔽(intSignificand × 10^{exponent - ff}) is 𝔽(number), and ff is as small as possible. If there are multiple possibilities for intSignificand, choose intSignificand such that 𝔽(intSignificand × 10^{exponent - ff}) is closest to 𝔽(number). If there are two such possible values of intSignificand, choose the one that is even.

Note 1

This method returns a String containing this Number value represented in decimal fixed-point notation with fractionDigits digits after the decimal point. If fractionDigits is undefined, 0 is assumed.

It performs the following steps when called:

1. Let number be ? ThisNumberValue(this value).
2. Let fractionCount be ? ToIntegerOrInfinity(fractionDigits).
3. Assert: If fractionDigits is undefined, then fractionCount is 0.
4. If fractionCount is not finite, throw a RangeError exception.
5. If fractionCount < 0 or fractionCount > 100, throw a RangeError exception.
6. If number is not finite, return Number::toString(number, 10).
7. Set number to ℝ(number).
8. Let sign be the empty String.
9. If number < 0, then
   1. Set sign to "-".
   2. Set number to -number.
10. If number ≥ 10²¹, then
    1. Let digitString be ! ToString(𝔽(number)).
11. Else,
    1. Let intValue be an integer for which intValue / 10^{fractionCount} - number is as close to zero as possible. If there are two such intValue, pick the larger intValue.
    2. If intValue = 0, let digitString be "0"; else let digitString be the String value consisting of the digits of the decimal representation of intValue (in order, with no leading zeroes).
    3. If fractionCount ≠ 0, then
       1. Let digitCount be the length of digitString.
       2. If digitCount ≤ fractionCount, then
          1. Let zeroPad be the String value consisting of fractionCount + 1 - digitCount occurrences of the code unit 0x0030 (DIGIT ZERO).
          2. Set digitString to the string-concatenation of zeroPad and digitString.
          3. Set digitCount to fractionCount + 1.
       3. Let intPart be the first digitCount - fractionCount code units of digitString.
       4. Let fractionalPart be the other fractionCount code units of digitString.
       5. Set digitString to the string-concatenation of intPart, ".", and fractionalPart.
12. Return the string-concatenation of sign and digitString.

Note 2

The output of toFixed may be more precise than toString for some values because toString only prints enough significant digits to distinguish the number from adjacent Number values. For example,

(1000000000000000128).toString() returns "1000000000000000100", while
(1000000000000000128).toFixed(0) returns "1000000000000000128".

An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement this method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of this method is used:

This method produces a String value that represents this Number value formatted according to the conventions of the host environment's current locale. This method is implementation-defined, and it is permissible, but not encouraged, for it to return the same thing as toString.

The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.

This method returns a String containing this Number value represented either in decimal exponential notation with one digit before the significand's decimal point and precision - 1 digits after the significand's decimal point or in decimal fixed notation with precision significant digits. If precision is undefined, it calls ToString instead.

It performs the following steps when called:

1. Let number be ? ThisNumberValue(this value).
2. If precision is undefined, return ! ToString(number).
3. Let precisionCount be ? ToIntegerOrInfinity(precision).
4. If number is not finite, return Number::toString(number, 10).
5. If precisionCount < 1 or precisionCount > 100, throw a RangeError exception.
6. Set number to ℝ(number).
7. Let sign be the empty String.
8. If number < 0, then
   1. Set sign to the code unit 0x002D (HYPHEN-MINUS).
   2. Set number to -number.
9. If number = 0, then
   1. Let significand be the String value consisting of precisionCount occurrences of the code unit 0x0030 (DIGIT ZERO).
   2. Let exponent be 0.
10. Else,
    1. Let exponent and intSignificand be integers such that 10^{precisionCount - 1} ≤ intSignificand < 10^{precisionCount} and for which intSignificand × 10^{exponent - precisionCount + 1} - number is as close to zero as possible. If there are two such sets of exponent and intSignificand, pick the exponent and intSignificand for which intSignificand × 10^{exponent - precisionCount + 1} is larger.
    2. Let significand be the String value consisting of the digits of the decimal representation of intSignificand (in order, with no leading zeroes).
    3. If exponent < -6 or exponent ≥ precisionCount, then
       1. Assert: exponent ≠ 0.
       2. If precisionCount ≠ 1, then
          1. Let intPart be the first code unit of significand.
          2. Let fractionalPart be the other precisionCount - 1 code units of significand.
          3. Set significand to the string-concatenation of intPart, ".", and fractionalPart.
       3. If exponent > 0, then
          1. Let exponentSign be the code unit 0x002B (PLUS SIGN).
       4. Else,
          1. Assert: exponent < 0.
          2. Let exponentSign be the code unit 0x002D (HYPHEN-MINUS).
          3. Set exponent to -exponent.
       5. Let exponentDigits be the String value consisting of the digits of the decimal representation of exponent (in order, with no leading zeroes).
       6. Return the string-concatenation of sign, significand, the code unit 0x0065 (LATIN SMALL LETTER E), exponentSign, and exponentDigits.
11. If exponent = precisionCount - 1, return the string-concatenation of sign and significand.
12. If exponent ≥ 0, then
    1. Set significand to the string-concatenation of the first exponent + 1 code units of significand, the code unit 0x002E (FULL STOP), and the remaining precisionCount - (exponent + 1) code units of significand.
13. Else,
    1. Set significand to the string-concatenation of the code unit 0x0030 (DIGIT ZERO), the code unit 0x002E (FULL STOP), -(exponent + 1) occurrences of the code unit 0x0030 (DIGIT ZERO), and the String significand.
14. Return the string-concatenation of sign and significand.

Note

The optional radix should be an integral Number value in the inclusive interval from 2_𝔽 to 36_𝔽. If radix is undefined then 10_𝔽 is used as the value of radix.

This method performs the following steps when called:

1. Let x be ? ThisNumberValue(this value).
2. If radix is undefined, let radixMV be 10.
3. Else, let radixMV be ? ToIntegerOrInfinity(radix).
4. If radixMV is not in the inclusive interval from 2 to 36, throw a RangeError exception.
5. Return Number::toString(x, radixMV).

This method is not generic; it throws a TypeError exception if its this value is not a Number or a Number object. Therefore, it cannot be transferred to other kinds of objects for use as a method.

The "length" property of this method is 1_𝔽.

1. Return ? ThisNumberValue(this value).

This function performs the following steps when called:

1. If NewTarget is not undefined, throw a TypeError exception.
2. Let primitive be ? ToPrimitive(value, number).
3. If primitive is a Number, return ? NumberToBigInt(primitive).
4. Return ? ToBigInt(primitive).

This function performs the following steps when called:

1. Set bits to ? ToIndex(bits).
2. Set bigint to ? ToBigInt(bigint).
3. Let module be ℝ(bigint) modulo 2^bits.
4. If module ≥ 2^{bits - 1}, return ℤ(module - 2^bits).
5. Return ℤ(module).

This function performs the following steps when called:

1. Set bits to ? ToIndex(bits).
2. Set bigint to ? ToBigInt(bigint).
3. Return ℤ(ℝ(bigint) modulo 2^bits).

The initial value of BigInt.prototype is the BigInt prototype object.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The initial value of BigInt.prototype.constructor is %BigInt%.

An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement this method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of this method is used:

This method produces a String value that represents this BigInt value formatted according to the conventions of the host environment's current locale. This method is implementation-defined, and it is permissible, but not encouraged, for it to return the same thing as toString.

The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.

Note

The optional radix should be an integral Number value in the inclusive interval from 2_𝔽 to 36_𝔽. If radix is undefined then 10_𝔽 is used as the value of radix.

This method performs the following steps when called:

1. Let x be ? ThisBigIntValue(this value).
2. If radix is undefined, let radixMV be 10.
3. Else, let radixMV be ? ToIntegerOrInfinity(radix).
4. If radixMV is not in the inclusive interval from 2 to 36, throw a RangeError exception.
5. Return BigInt::toString(x, radixMV).

This method is not generic; it throws a TypeError exception if its this value is not a BigInt or a BigInt object. Therefore, it cannot be transferred to other kinds of objects for use as a method.

1. Return ? ThisBigIntValue(this value).

The initial value of the %Symbol.toStringTag% property is the String value "BigInt".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

The Number value for e, the base of the natural logarithms, which is approximately 2.7182818284590452354.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The Number value for the natural logarithm of 10, which is approximately 2.302585092994046.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The Number value for the natural logarithm of 2, which is approximately 0.6931471805599453.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The Number value for the base-10 logarithm of e, the base of the natural logarithms; this value is approximately 0.4342944819032518.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

Note

The value of Math.LOG10E is approximately the reciprocal of the value of Math.LN10.

The Number value for the base-2 logarithm of e, the base of the natural logarithms; this value is approximately 1.4426950408889634.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

Note

The value of Math.LOG2E is approximately the reciprocal of the value of Math.LN2.

The Number value for π, the ratio of the circumference of a circle to its diameter, which is approximately 3.1415926535897932.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The Number value for the square root of ½, which is approximately 0.7071067811865476.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

Note

The value of Math.SQRT1_2 is approximately the reciprocal of the value of Math.SQRT2.

The Number value for the square root of 2, which is approximately 1.4142135623730951.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The initial value of the %Symbol.toStringTag% property is the String value "Math".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

This function returns the absolute value of x; the result has the same magnitude as x but has positive sign.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is NaN, return NaN.
3. If n is -0_𝔽, return +0_𝔽.
4. If n is -∞_𝔽, return +∞_𝔽.
5. If n < -0_𝔽, return -n.
6. Return n.

This function returns the inverse cosine of x. The result is expressed in radians and is in the inclusive interval from +0_𝔽 to 𝔽(π).

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is NaN, n > 1_𝔽, or n < -1_𝔽, return NaN.
3. If n is 1_𝔽, return +0_𝔽.
4. Return an implementation-approximated Number value representing the inverse cosine of ℝ(n).

This function returns the inverse hyperbolic cosine of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is either NaN or +∞_𝔽, return n.
3. If n is 1_𝔽, return +0_𝔽.
4. If n < 1_𝔽, return NaN.
5. Return an implementation-approximated Number value representing the inverse hyperbolic cosine of ℝ(n).

This function returns the inverse sine of x. The result is expressed in radians and is in the inclusive interval from 𝔽(-π / 2) to 𝔽(π / 2).

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is one of NaN, +0_𝔽, or -0_𝔽, return n.
3. If n > 1_𝔽 or n < -1_𝔽, return NaN.
4. Return an implementation-approximated Number value representing the inverse sine of ℝ(n).

This function returns the inverse hyperbolic sine of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is not finite or n is either +0_𝔽 or -0_𝔽, return n.
3. Return an implementation-approximated Number value representing the inverse hyperbolic sine of ℝ(n).

This function returns the inverse tangent of x. The result is expressed in radians and is in the inclusive interval from 𝔽(-π / 2) to 𝔽(π / 2).

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is one of NaN, +0_𝔽, or -0_𝔽, return n.
3. If n is +∞_𝔽, return an implementation-approximated Number value representing π / 2.
4. If n is -∞_𝔽, return an implementation-approximated Number value representing -π / 2.
5. Return an implementation-approximated Number value representing the inverse tangent of ℝ(n).

This function returns the inverse hyperbolic tangent of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is one of NaN, +0_𝔽, or -0_𝔽, return n.
3. If n > 1_𝔽 or n < -1_𝔽, return NaN.
4. If n is 1_𝔽, return +∞_𝔽.
5. If n is -1_𝔽, return -∞_𝔽.
6. Return an implementation-approximated Number value representing the inverse hyperbolic tangent of ℝ(n).

This function returns the inverse tangent of the quotient y / x of the arguments y and x, where the signs of y and x are used to determine the quadrant of the result. Note that it is intentional and traditional for the two-argument inverse tangent function that the argument named y be first and the argument named x be second. The result is expressed in radians and is in the inclusive interval from -π to +π.

It performs the following steps when called:

1. Let ny be ? ToNumber(y).
2. Let nx be ? ToNumber(x).
3. If ny is NaN or nx is NaN, return NaN.
4. If ny is +∞_𝔽, then
   1. If nx is +∞_𝔽, return an implementation-approximated Number value representing π / 4.
   2. If nx is -∞_𝔽, return an implementation-approximated Number value representing 3π / 4.
   3. Return an implementation-approximated Number value representing π / 2.
5. If ny is -∞_𝔽, then
   1. If nx is +∞_𝔽, return an implementation-approximated Number value representing -π / 4.
   2. If nx is -∞_𝔽, return an implementation-approximated Number value representing -3π / 4.
   3. Return an implementation-approximated Number value representing -π / 2.
6. If ny is +0_𝔽, then
   1. If nx > +0_𝔽 or nx is +0_𝔽, return +0_𝔽.
   2. Return an implementation-approximated Number value representing π.
7. If ny is -0_𝔽, then
   1. If nx > +0_𝔽 or nx is +0_𝔽, return -0_𝔽.
   2. Return an implementation-approximated Number value representing -π.
8. Assert: ny is finite and is neither +0_𝔽 nor -0_𝔽.
9. If ny > +0_𝔽, then
   1. If nx is +∞_𝔽, return +0_𝔽.
   2. If nx is -∞_𝔽, return an implementation-approximated Number value representing π.
   3. If nx is either +0_𝔽 or -0_𝔽, return an implementation-approximated Number value representing π / 2.
10. If ny < -0_𝔽, then
    1. If nx is +∞_𝔽, return -0_𝔽.
    2. If nx is -∞_𝔽, return an implementation-approximated Number value representing -π.
    3. If nx is either +0_𝔽 or -0_𝔽, return an implementation-approximated Number value representing -π / 2.
11. Assert: nx is finite and is neither +0_𝔽 nor -0_𝔽.
12. Let result be the inverse tangent of abs(ℝ(ny) / ℝ(nx)).
13. If nx < -0_𝔽, then
    1. If ny > +0_𝔽, set result to π - result.
    2. Else, set result to -π + result.
14. Else,
    1. If ny < -0_𝔽, set result to -result.
15. Return an implementation-approximated Number value representing result.

This function returns the cube root of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is not finite or n is either +0_𝔽 or -0_𝔽, return n.
3. Return an implementation-approximated Number value representing the cube root of ℝ(n).

This function returns the smallest (closest to -∞) integral Number value that is not less than x. If x is already an integral Number, the result is x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is not finite or n is either +0_𝔽 or -0_𝔽, return n.
3. If n < -0_𝔽 and n > -1_𝔽, return -0_𝔽.
4. If n is an integral Number, return n.
5. Return the smallest (closest to -∞) integral Number value that is not less than n.

Note

The value of Math.ceil(x) is the same as the value of -Math.floor(-x).

This function performs the following steps when called:

1. Let n be ? ToUint32(x).
2. Let p be the number of leading zero bits in the unsigned 32-bit binary representation of n.
3. Return 𝔽(p).

Note

If n is either +0_𝔽 or -0_𝔽, this method returns 32_𝔽. If the most significant bit of the 32-bit binary encoding of n is 1, this method returns +0_𝔽.

This function returns the cosine of x. The argument is expressed in radians.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is not finite, return NaN.
3. If n is either +0_𝔽 or -0_𝔽, return 1_𝔽.
4. Return an implementation-approximated Number value representing the cosine of ℝ(n).

This function returns the hyperbolic cosine of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is NaN, return NaN.
3. If n is either +∞_𝔽 or -∞_𝔽, return +∞_𝔽.
4. If n is either +0_𝔽 or -0_𝔽, return 1_𝔽.
5. Return an implementation-approximated Number value representing the hyperbolic cosine of ℝ(n).

Note

The value of Math.cosh(x) is the same as the value of (Math.exp(x) + Math.exp(-x)) / 2.

This function returns the exponential function of x (e raised to the power of x, where e is the base of the natural logarithms).

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is either NaN or +∞_𝔽, return n.
3. If n is either +0_𝔽 or -0_𝔽, return 1_𝔽.
4. If n is -∞_𝔽, return +0_𝔽.
5. Return an implementation-approximated Number value representing the exponential function of ℝ(n).

This function returns the result of subtracting 1 from the exponential function of x (e raised to the power of x, where e is the base of the natural logarithms). The result is computed in a way that is accurate even when the value of x is close to 0.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is one of NaN, +0_𝔽, -0_𝔽, or +∞_𝔽, return n.
3. If n is -∞_𝔽, return -1_𝔽.
4. Let exp be the exponential function of ℝ(n).
5. Return an implementation-approximated Number value representing exp - 1.

This function returns the greatest (closest to +∞) integral Number value that is not greater than x. If x is already an integral Number, the result is x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is not finite or n is either +0_𝔽 or -0_𝔽, return n.
3. If n < 1_𝔽 and n > +0_𝔽, return +0_𝔽.
4. If n is an integral Number, return n.
5. Return the greatest (closest to +∞) integral Number value that is not greater than n.

Note

The value of Math.floor(x) is the same as the value of -Math.ceil(-x).

This function performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is NaN, return NaN.
3. If n is one of +0_𝔽, -0_𝔽, +∞_𝔽, or -∞_𝔽, return n.
4. Let n32 be the result of converting n to IEEE 754-2019 binary32 format using roundTiesToEven mode.
5. Let n64 be the result of converting n32 to IEEE 754-2019 binary64 format.
6. Return the ECMAScript Number value corresponding to n64.

This function performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is NaN, return NaN.
3. If n is one of +0_𝔽, -0_𝔽, +∞_𝔽, or -∞_𝔽, return n.
4. Let n16 be the result of converting n to IEEE 754-2019 binary16 format using roundTiesToEven mode.
5. Let n64 be the result of converting n16 to IEEE 754-2019 binary64 format.
6. Return the ECMAScript Number value corresponding to n64.

Note

This operation is not the same as casting to binary32 and then to binary16 because of the possibility of double-rounding: consider the number k = 1.00048828125000022204_𝔽, for example, for which Math.f16round(k) is 1.0009765625_𝔽, but Math.f16round(Math.fround(k)) is 1_𝔽.

Not all platforms provide native support for casting from binary64 to binary16. There are various libraries which can provide this, including the MIT-licensed half library. Alternatively, it is possible to first cast from binary64 to binary32 under roundTiesToEven and then check whether the result could lead to incorrect double-rounding. Such cases can be handled explicitly by adjusting the mantissa of the binary32 value so that it is the value which would be produced by performing the initial cast under roundTiesToOdd. Casting the adjusted value to binary16 under roundTiesToEven then produces the correct value.

Given zero or more arguments, this function returns the square root of the sum of squares of its arguments.

It performs the following steps when called:

1. Let coerced be a new empty List.
2. For each element arg of args, do
   1. Let n be ? ToNumber(arg).
   2. Append n to coerced.
3. For each element number of coerced, do
   1. If number is either +∞_𝔽 or -∞_𝔽, return +∞_𝔽.
4. Let onlyZero be true.
5. For each element number of coerced, do
   1. If number is NaN, return NaN.
   2. If number is neither +0_𝔽 nor -0_𝔽, set onlyZero to false.
6. If onlyZero is true, return +0_𝔽.
7. Return an implementation-approximated Number value representing the square root of the sum of squares of the mathematical values of the elements of coerced.

The "length" property of this function is 2_𝔽.

Note

Implementations should take care to avoid the loss of precision from overflows and underflows that are prone to occur in naive implementations when this function is called with two or more arguments.

This function performs the following steps when called:

1. Let a be ℝ(? ToUint32(x)).
2. Let b be ℝ(? ToUint32(y)).
3. Let product be (a × b) modulo 2³².
4. If product ≥ 2³¹, return 𝔽(product - 2³²).
5. Return 𝔽(product).

This function returns the natural logarithm of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is either NaN or +∞_𝔽, return n.
3. If n is 1_𝔽, return +0_𝔽.
4. If n is either +0_𝔽 or -0_𝔽, return -∞_𝔽.
5. If n < -0_𝔽, return NaN.
6. Return an implementation-approximated Number value representing ln(ℝ(n)).

This function returns the natural logarithm of 1 + x. The result is computed in a way that is accurate even when the value of x is close to zero.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is one of NaN, +0_𝔽, -0_𝔽, or +∞_𝔽, return n.
3. If n is -1_𝔽, return -∞_𝔽.
4. If n < -1_𝔽, return NaN.
5. Return an implementation-approximated Number value representing ln(1 + ℝ(n)).

This function returns the base 10 logarithm of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is either NaN or +∞_𝔽, return n.
3. If n is 1_𝔽, return +0_𝔽.
4. If n is either +0_𝔽 or -0_𝔽, return -∞_𝔽.
5. If n < -0_𝔽, return NaN.
6. Return an implementation-approximated Number value representing log10(ℝ(n)).

This function returns the base 2 logarithm of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is either NaN or +∞_𝔽, return n.
3. If n is 1_𝔽, return +0_𝔽.
4. If n is either +0_𝔽 or -0_𝔽, return -∞_𝔽.
5. If n < -0_𝔽, return NaN.
6. Return an implementation-approximated Number value representing log2(ℝ(n)).

Given zero or more arguments, this function calls ToNumber on each of the arguments and returns the largest of the resulting values.

It performs the following steps when called:

1. Let coerced be a new empty List.
2. For each element arg of args, do
   1. Let n be ? ToNumber(arg).
   2. Append n to coerced.
3. Let highest be -∞_𝔽.
4. For each element number of coerced, do
   1. If number is NaN, return NaN.
   2. If number is +0_𝔽 and highest is -0_𝔽, set highest to +0_𝔽.
   3. If number > highest, set highest to number.
5. Return highest.

Note

The comparison of values to determine the largest value is done using the IsLessThan algorithm except that +0_𝔽 is considered to be larger than -0_𝔽.

The "length" property of this function is 2_𝔽.

Given zero or more arguments, this function calls ToNumber on each of the arguments and returns the smallest of the resulting values.

It performs the following steps when called:

1. Let coerced be a new empty List.
2. For each element arg of args, do
   1. Let n be ? ToNumber(arg).
   2. Append n to coerced.
3. Let lowest be +∞_𝔽.
4. For each element number of coerced, do
   1. If number is NaN, return NaN.
   2. If number is -0_𝔽 and lowest is +0_𝔽, set lowest to -0_𝔽.
   3. If number < lowest, set lowest to number.
5. Return lowest.

Note

The comparison of values to determine the smallest value is done using the IsLessThan algorithm except that +0_𝔽 is considered to be larger than -0_𝔽.

The "length" property of this function is 2_𝔽.

This function performs the following steps when called:

1. Set base to ? ToNumber(base).
2. Set exponent to ? ToNumber(exponent).
3. Return Number::exponentiate(base, exponent).

This function returns a Number value with positive sign, greater than or equal to +0_𝔽 but strictly less than 1_𝔽, chosen randomly or pseudo randomly with approximately uniform distribution over that range, using an implementation-defined algorithm or strategy.

Each Math.random function created for distinct realms must produce a distinct sequence of values from successive calls.

This function returns the Number value that is closest to x and is integral. If two integral Numbers are equally close to x, then the result is the Number value that is closer to +∞. If x is already integral, the result is x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is not finite or n is an integral Number, return n.
3. If n < 0.5_𝔽 and n > +0_𝔽, return +0_𝔽.
4. If n < -0_𝔽 and n ≥ -0.5_𝔽, return -0_𝔽.
5. Return the integral Number closest to n, preferring the Number closer to +∞ in the case of a tie.

Note 1

Math.round(3.5) returns 4, but Math.round(-3.5) returns -3.

Note 2

The value of Math.round(x) is not always the same as the value of Math.floor(x + 0.5). When x is -0_𝔽 or x is less than -0_𝔽 but greater than or equal to -0.5_𝔽, Math.round(x) returns -0_𝔽, but Math.floor(x + 0.5) returns +0_𝔽. Math.round(x) may also differ from the value of Math.floor(x + 0.5)because of internal rounding when computing x + 0.5.

This function returns the sign of x, indicating whether x is positive, negative, or zero.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is one of NaN, +0_𝔽, or -0_𝔽, return n.
3. If n < -0_𝔽, return -1_𝔽.
4. Return 1_𝔽.

This function returns the sine of x. The argument is expressed in radians.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is one of NaN, +0_𝔽, or -0_𝔽, return n.
3. If n is either +∞_𝔽 or -∞_𝔽, return NaN.
4. Return an implementation-approximated Number value representing the sine of ℝ(n).

This function returns the hyperbolic sine of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is not finite or n is either +0_𝔽 or -0_𝔽, return n.
3. Return an implementation-approximated Number value representing the hyperbolic sine of ℝ(n).

Note

The value of Math.sinh(x) is the same as the value of (Math.exp(x) - Math.exp(-x)) / 2.

This function returns the square root of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is one of NaN, +0_𝔽, -0_𝔽, or +∞_𝔽, return n.
3. If n < -0_𝔽, return NaN.
4. Return 𝔽(the square root of ℝ(n)).

Given an iterable of Numbers, this function sums each value in the iterable and returns their sum. If any value is not a Number it throws a TypeError exception.

It performs the following steps when called:

1. Perform ? RequireObjectCoercible(items).
2. Let iteratorRecord be ? GetIterator(items, sync).
3. Let state be minus-zero.
4. Let sum be 0.
5. Let count be 0.
6. Let next be not-started.
7. Repeat, while next is not done,
   1. Set next to ? IteratorStepValue(iteratorRecord).
   2. If next is not done, then
      1. If count ≥ 2⁵³ - 1, then
         1. NOTE: This step is not expected to be reached in practice and is included only so that implementations may rely on inputs being “reasonably sized” without violating this specification.
         2. Let error be ThrowCompletion(a newly created RangeError object).
         3. Return ? IteratorClose(iteratorRecord, error).
      2. If next is not a Number, then
         1. Let error be ThrowCompletion(a newly created TypeError object).
         2. Return ? IteratorClose(iteratorRecord, error).
      3. Let n be next.
      4. If state is not not-a-number, then
         1. If n is NaN, then
            1. Set state to not-a-number.
         2. Else if n is +∞_𝔽, then
            1. If state is minus-infinity, set state to not-a-number.
            2. Else, set state to plus-infinity.
         3. Else if n is -∞_𝔽, then
            1. If state is plus-infinity, set state to not-a-number.
            2. Else, set state to minus-infinity.
         4. Else if n is not -0_𝔽 and state is either minus-zero or finite, then
            1. Set state to finite.
            2. Set sum to sum + ℝ(n).
      5. Set count to count + 1.
8. If state is not-a-number, return NaN.
9. If state is plus-infinity, return +∞_𝔽.
10. If state is minus-infinity, return -∞_𝔽.
11. If state is minus-zero, return -0_𝔽.
12. Return 𝔽(sum).

Note

The value of sum can be computed without arbitrary-precision arithmetic by a variety of algorithms. One such is the “Grow-Expansion” algorithm given in Adaptive Precision Floating-Point Arithmetic and Fast Robust Geometric Predicates by Jonathan Richard Shewchuk. A more recent algorithm is given in “Fast exact summation using small and large superaccumulators”, code for which is available at https://gitlab.com/radfordneal/xsum.

This function returns the tangent of x. The argument is expressed in radians.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is one of NaN, +0_𝔽, or -0_𝔽, return n.
3. If n is either +∞_𝔽 or -∞_𝔽, return NaN.
4. Return an implementation-approximated Number value representing the tangent of ℝ(n).

This function returns the hyperbolic tangent of x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is one of NaN, +0_𝔽, or -0_𝔽, return n.
3. If n is +∞_𝔽, return 1_𝔽.
4. If n is -∞_𝔽, return -1_𝔽.
5. Return an implementation-approximated Number value representing the hyperbolic tangent of ℝ(n).

Note

The value of Math.tanh(x) is the same as the value of (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x)).

This function returns the integral part of the number x, removing any fractional digits. If x is already integral, the result is x.

It performs the following steps when called:

1. Let n be ? ToNumber(x).
2. If n is not finite or n is either +0_𝔽 or -0_𝔽, return n.
3. If n < 1_𝔽 and n > +0_𝔽, return +0_𝔽.
4. If n < -0_𝔽 and n > -1_𝔽, return -0_𝔽.
5. Return the integral Number nearest n in the direction of +0_𝔽.

Time measurement in ECMAScript is analogous to time measurement in POSIX, in particular sharing definition in terms of the proleptic Gregorian calendar, an epoch of midnight at the beginning of 1 January 1970 UTC, and an accounting of every day as comprising exactly 86,400 seconds (each of which is 1000 milliseconds long).

An ECMAScript time value is a Number, either a finite integral Number representing an instant in time to millisecond precision or NaN representing no specific instant. A time value that is a multiple of 24 × 60 × 60 × 1000 = 86,400,000 (i.e., is 86,400,000 × d for some integer d) represents the instant at the start of the UTC day that follows the epoch by d whole UTC days (preceding the epoch for negative d). Every other finite time value tv is defined relative to the greatest preceding time value s that is such a multiple, and represents the instant that occurs within the same UTC day as s but follows it by (tv - s) milliseconds.

Time values do not account for UTC leap seconds—there are no time values representing instants within positive leap seconds, and there are time values representing instants removed from the UTC timeline by negative leap seconds. However, the definition of time values nonetheless yields piecewise alignment with UTC, with discontinuities only at leap second boundaries and zero difference outside of leap seconds.

A Number can exactly represent all integers from -9,007,199,254,740,992 to 9,007,199,254,740,992 (21.1.2.8 and 21.1.2.6). A time value supports a slightly smaller range of -8,640,000,000,000,000 to 8,640,000,000,000,000 milliseconds. This yields a supported time value range of exactly -100,000,000 days to 100,000,000 days relative to midnight at the beginning of 1 January 1970 UTC.

The exact moment of midnight at the beginning of 1 January 1970 UTC is represented by the time value +0_𝔽.

Note

In the proleptic Gregorian calendar, leap years are precisely those which are both divisible by 4 and either divisible by 400 or not divisible by 100.

The 400 year cycle of the proleptic Gregorian calendar contains 97 leap years. This yields an average of 365.2425 days per year, which is 31,556,952,000 milliseconds. Therefore, the maximum range a Number could represent exactly with millisecond precision is approximately -285,426 to 285,426 years relative to 1970. The smaller range supported by a time value as specified in this section is approximately -273,790 to 273,790 years relative to 1970.

These constants are referenced by algorithms in the following sections.

HoursPerDay = 24 MinutesPerHour = 60 SecondsPerMinute = 60 msPerSecond = 1000_𝔽 msPerMinute = 60000_𝔽 = msPerSecond × 𝔽(SecondsPerMinute) msPerHour = 3600000_𝔽 = msPerMinute × 𝔽(MinutesPerHour) msPerDay = 86400000_𝔽 = msPerHour × 𝔽(HoursPerDay)

The abstract operation Day takes argument tv (a finite time value) and returns an integral Number. It returns the day number of the day in which tv falls. It performs the following steps when called:

1. Return 𝔽(floor(ℝ(tv / msPerDay))).

The abstract operation TimeWithinDay takes argument tv (a finite time value) and returns an integral Number in the interval from +0_𝔽 (inclusive) to msPerDay (exclusive). It returns the number of milliseconds since the start of the day in which tv falls. It performs the following steps when called:

1. Return 𝔽(ℝ(tv) modulo ℝ(msPerDay)).

The abstract operation DaysInYear takes argument y (an integral Number) and returns 365_𝔽 or 366_𝔽. It returns the number of days in year y. Leap years have 366 days; all other years have 365. It performs the following steps when called:

1. Let ry be ℝ(y).
2. If (ry modulo 400) = 0, return 366_𝔽.
3. If (ry modulo 100) = 0, return 365_𝔽.
4. If (ry modulo 4) = 0, return 366_𝔽.
5. Return 365_𝔽.

The abstract operation DayFromYear takes argument y (an integral Number) and returns an integral Number. It returns the day number of the first day of year y. It performs the following steps when called:

1. Let ry be ℝ(y).
2. NOTE: In the following steps, numberYears1, numberYears4, numberYears100, and numberYears400 represent the number of years divisible by 1, 4, 100, and 400, respectively, that occur between the epoch and the start of year y. The number is negative if y is before the epoch.
3. Let numberYears1 be (ry - 1970).
4. Let numberYears4 be floor((ry - 1969) / 4).
5. Let numberYears100 be floor((ry - 1901) / 100).
6. Let numberYears400 be floor((ry - 1601) / 400).
7. Return 𝔽(365 × numberYears1 + numberYears4 - numberYears100 + numberYears400).

The abstract operation TimeFromYear takes argument y (an integral Number) and returns a time value. It returns the time value of the start of year y. It performs the following steps when called:

1. Return msPerDay × DayFromYear(y).

The abstract operation YearFromTime takes argument tv (a finite time value) and returns an integral Number. It returns the year in which tv falls. It performs the following steps when called:

1. Return the largest integral Number y (closest to +∞) such that TimeFromYear(y) ≤ tv.

The abstract operation DayWithinYear takes argument tv (a finite time value) and returns an integral Number in the inclusive interval from +0_𝔽 to 365_𝔽. It performs the following steps when called:

1. Return Day(tv) - DayFromYear(YearFromTime(tv)).

The abstract operation InLeapYear takes argument tv (a finite time value) and returns +0_𝔽 or 1_𝔽. It returns 1_𝔽 if tv is within a leap year and +0_𝔽 otherwise. It performs the following steps when called:

1. If DaysInYear(YearFromTime(tv)) is 366_𝔽, return 1_𝔽.
2. Return +0_𝔽.

The abstract operation MonthFromTime takes argument tv (a finite time value) and returns an integral Number in the inclusive interval from +0_𝔽 to 11_𝔽. It returns a Number identifying the month in which tv falls. A month value of +0_𝔽 specifies January; 1_𝔽 specifies February; 2_𝔽 specifies March; 3_𝔽 specifies April; 4_𝔽 specifies May; 5_𝔽 specifies June; 6_𝔽 specifies July; 7_𝔽 specifies August; 8_𝔽 specifies September; 9_𝔽 specifies October; 10_𝔽 specifies November; and 11_𝔽 specifies December. Note that MonthFromTime(+0_𝔽) = +0_𝔽, corresponding to Thursday, 1 January 1970. It performs the following steps when called:

1. Let inLeapYear be InLeapYear(tv).
2. Let dayWithinYear be DayWithinYear(tv).
3. If dayWithinYear < 31_𝔽, return +0_𝔽.
4. If dayWithinYear < 59_𝔽 + inLeapYear, return 1_𝔽.
5. If dayWithinYear < 90_𝔽 + inLeapYear, return 2_𝔽.
6. If dayWithinYear < 120_𝔽 + inLeapYear, return 3_𝔽.
7. If dayWithinYear < 151_𝔽 + inLeapYear, return 4_𝔽.
8. If dayWithinYear < 181_𝔽 + inLeapYear, return 5_𝔽.
9. If dayWithinYear < 212_𝔽 + inLeapYear, return 6_𝔽.
10. If dayWithinYear < 243_𝔽 + inLeapYear, return 7_𝔽.
11. If dayWithinYear < 273_𝔽 + inLeapYear, return 8_𝔽.
12. If dayWithinYear < 304_𝔽 + inLeapYear, return 9_𝔽.
13. If dayWithinYear < 334_𝔽 + inLeapYear, return 10_𝔽.
14. Assert: dayWithinYear < 365_𝔽 + inLeapYear.
15. Return 11_𝔽.

The abstract operation DateFromTime takes argument tv (a finite time value) and returns an integral Number in the inclusive interval from 1_𝔽 to 31_𝔽. It returns the day of the month in which tv falls. It performs the following steps when called:

1. Let inLeapYear be InLeapYear(tv).
2. Let dayWithinYear be DayWithinYear(tv).
3. Let month be MonthFromTime(tv).
4. If month is +0_𝔽, return dayWithinYear + 1_𝔽.
5. If month is 1_𝔽, return dayWithinYear - 30_𝔽.
6. If month is 2_𝔽, return dayWithinYear - 58_𝔽 - inLeapYear.
7. If month is 3_𝔽, return dayWithinYear - 89_𝔽 - inLeapYear.
8. If month is 4_𝔽, return dayWithinYear - 119_𝔽 - inLeapYear.
9. If month is 5_𝔽, return dayWithinYear - 150_𝔽 - inLeapYear.
10. If month is 6_𝔽, return dayWithinYear - 180_𝔽 - inLeapYear.
11. If month is 7_𝔽, return dayWithinYear - 211_𝔽 - inLeapYear.
12. If month is 8_𝔽, return dayWithinYear - 242_𝔽 - inLeapYear.
13. If month is 9_𝔽, return dayWithinYear - 272_𝔽 - inLeapYear.
14. If month is 10_𝔽, return dayWithinYear - 303_𝔽 - inLeapYear.
15. Assert: month is 11_𝔽.
16. Return dayWithinYear - 333_𝔽 - inLeapYear.

The abstract operation WeekDay takes argument tv (a finite time value) and returns an integral Number in the inclusive interval from +0_𝔽 to 6_𝔽. It returns a Number identifying the day of the week in which tv falls. A weekday value of +0_𝔽 specifies Sunday; 1_𝔽 specifies Monday; 2_𝔽 specifies Tuesday; 3_𝔽 specifies Wednesday; 4_𝔽 specifies Thursday; 5_𝔽 specifies Friday; and 6_𝔽 specifies Saturday. Note that WeekDay(+0_𝔽) = 4_𝔽, corresponding to Thursday, 1 January 1970. It performs the following steps when called:

1. Return 𝔽(ℝ(Day(tv) + 4_𝔽) modulo 7).

The abstract operation HourFromTime takes argument tv (a finite time value) and returns an integral Number in the inclusive interval from +0_𝔽 to 23_𝔽. It returns the hour of the day in which tv falls. It performs the following steps when called:

1. Return 𝔽(floor(ℝ(tv / msPerHour)) modulo HoursPerDay).

The abstract operation MinFromTime takes argument tv (a finite time value) and returns an integral Number in the inclusive interval from +0_𝔽 to 59_𝔽. It returns the minute of the hour in which tv falls. It performs the following steps when called:

1. Return 𝔽(floor(ℝ(tv / msPerMinute)) modulo MinutesPerHour).

The abstract operation SecFromTime takes argument tv (a finite time value) and returns an integral Number in the inclusive interval from +0_𝔽 to 59_𝔽. It returns the second of the minute in which tv falls. It performs the following steps when called:

1. Return 𝔽(floor(ℝ(tv / msPerSecond)) modulo SecondsPerMinute).

The abstract operation msFromTime takes argument tv (a finite time value) and returns an integral Number in the inclusive interval from +0_𝔽 to 999_𝔽. It returns the millisecond of the second in which tv falls. It performs the following steps when called:

1. Return 𝔽(ℝ(tv) modulo ℝ(msPerSecond)).

The abstract operation GetUTCEpochNanoseconds takes arguments year (an integer), month (an integer in the inclusive interval from 1 to 12), day (an integer in the inclusive interval from 1 to 31), hour (an integer in the inclusive interval from 0 to 23), minute (an integer in the inclusive interval from 0 to 59), second (an integer in the inclusive interval from 0 to 59), millisecond (an integer in the inclusive interval from 0 to 999), microsecond (an integer in the inclusive interval from 0 to 999), and nanosecond (an integer in the inclusive interval from 0 to 999) and returns a BigInt. The returned value represents a number of nanoseconds since the epoch that corresponds to the given ISO 8601 calendar date and wall-clock time in UTC. It performs the following steps when called:

1. Let date be MakeDay(𝔽(year), 𝔽(month - 1), 𝔽(day)).
2. Let time be MakeTime(𝔽(hour), 𝔽(minute), 𝔽(second), 𝔽(millisecond)).
3. Let ms be MakeDate(date, time).
4. Assert: ms is an integral Number.
5. Return ℤ(ℝ(ms) × 10⁶ + microsecond × 10³ + nanosecond).

Time zones in ECMAScript are represented by time zone identifiers, which are Strings composed entirely of code units in the inclusive interval from 0x0000 to 0x007F. Time zones supported by an ECMAScript implementation may be available named time zones, represented by the [[Identifier]] field of the Time Zone Identifier Records returned by AvailableNamedTimeZoneIdentifiers, or offset time zones, represented by Strings for which IsTimeZoneOffsetString returns true.

A primary time zone identifier is the preferred identifier for an available named time zone. A non-primary time zone identifier is an identifier for an available named time zone that is not a primary time zone identifier. An available named time zone identifier is either a primary time zone identifier or a non-primary time zone identifier. Each available named time zone identifier is associated with exactly one available named time zone. Each available named time zone is associated with exactly one primary time zone identifier and zero or more non-primary time zone identifiers.

ECMAScript implementations must support an available named time zone with the identifier "UTC", which must be the primary time zone identifier for the UTC time zone. In addition, implementations may support any number of other available named time zones.

Implementations that follow the requirements for time zones as described in the ECMA-402 Internationalization API specification are called time zone aware. Time zone aware implementations must support available named time zones corresponding to the Zone and Link names of the IANA Time Zone Database, and only such names. In time zone aware implementations, a primary time zone identifier is a Zone name, and a non-primary time zone identifier is a Link name, respectively, in the IANA Time Zone Database except as specifically overridden by AvailableNamedTimeZoneIdentifiers as specified in the ECMA-402 specification. Implementations that do not support the entire IANA Time Zone Database are still recommended to use IANA Time Zone Database names as identifiers to represent time zones.

The implementation-defined abstract operation GetNamedTimeZoneEpochNanoseconds takes arguments timeZoneIdentifier (a String), year (an integer), month (an integer in the inclusive interval from 1 to 12), day (an integer in the inclusive interval from 1 to 31), hour (an integer in the inclusive interval from 0 to 23), minute (an integer in the inclusive interval from 0 to 59), second (an integer in the inclusive interval from 0 to 59), millisecond (an integer in the inclusive interval from 0 to 999), microsecond (an integer in the inclusive interval from 0 to 999), and nanosecond (an integer in the inclusive interval from 0 to 999) and returns a List of BigInts. Each value in the returned List represents a number of nanoseconds since the epoch that corresponds to the given ISO 8601 calendar date and wall-clock time in the named time zone identified by timeZoneIdentifier.

When the input represents a local time occurring more than once because of a negative time zone transition (e.g. when daylight saving time ends or the time zone offset is decreased due to a time zone rule change), the returned List will have more than one element and will be sorted by ascending numerical value. When the input represents a local time skipped because of a positive time zone transition (e.g. when daylight saving time begins or the time zone offset is increased due to a time zone rule change), the returned List will be empty. Otherwise, the returned List will have one element.

The default implementation of GetNamedTimeZoneEpochNanoseconds, to be used for ECMAScript implementations that do not include local political rules for any time zones, performs the following steps when called:

1. Assert: timeZoneIdentifier is "UTC".
2. Let epochNanoseconds be GetUTCEpochNanoseconds(year, month, day, hour, minute, second, millisecond, microsecond, nanosecond).
3. Return « epochNanoseconds ».

Note

It is required for time zone aware implementations (and recommended for all others) to use the time zone information of the IANA Time Zone Database https://www.iana.org/time-zones/.

1:30 AM on 5 November 2017 in America/New_York is repeated twice, so GetNamedTimeZoneEpochNanoseconds("America/New_York", 2017, 11, 5, 1, 30, 0, 0, 0, 0) would return a List of length 2 in which the first element represents 05:30 UTC (corresponding with 01:30 US Eastern Daylight Time at UTC offset -04:00) and the second element represents 06:30 UTC (corresponding with 01:30 US Eastern Standard Time at UTC offset -05:00).

2:30 AM on 12 March 2017 in America/New_York does not exist, so GetNamedTimeZoneEpochNanoseconds("America/New_York", 2017, 3, 12, 2, 30, 0, 0, 0, 0) would return an empty List.

The implementation-defined abstract operation GetNamedTimeZoneOffsetNanoseconds takes arguments timeZoneIdentifier (a String) and epochNanoseconds (a BigInt) and returns an integer.

The returned integer represents the offset from UTC of the named time zone identified by timeZoneIdentifier, at the instant corresponding with epochNanoseconds relative to the epoch, both in nanoseconds.

The default implementation of GetNamedTimeZoneOffsetNanoseconds, to be used for ECMAScript implementations that do not include local political rules for any time zones, performs the following steps when called:

1. Assert: timeZoneIdentifier is "UTC".
2. Return 0.

Note

Time zone offset values may be positive or negative.

A Time Zone Identifier Record is a Record used to describe an available named time zone identifier and its corresponding primary time zone identifier.

Time Zone Identifier Records have the fields listed in Table 59.

Field Name	Value	Meaning
[[Identifier]]	a String	An available named time zone identifier that is supported by the implementation.
[[PrimaryIdentifier]]	a String	The primary time zone identifier that [[Identifier]] resolves to.

Note

If [[Identifier]] is a primary time zone identifier, then [[Identifier]] is [[PrimaryIdentifier]].

The implementation-defined abstract operation AvailableNamedTimeZoneIdentifiers takes no arguments and returns a List of Time Zone Identifier Records. Its result describes all available named time zone identifiers in this implementation, as well as the primary time zone identifier corresponding to each available named time zone identifier. The List is ordered according to the [[Identifier]] field of each Time Zone Identifier Record.

Time zone aware implementations, including all implementations that implement the ECMA-402 Internationalization API, must implement the AvailableNamedTimeZoneIdentifiers abstract operation as specified in the ECMA-402 specification. For implementations that are not time zone aware, AvailableNamedTimeZoneIdentifiers performs the following steps when called:

1. If the implementation does not include local political rules for any time zones, then
   1. Return « the Time Zone Identifier Record { [[Identifier]]: "UTC", [[PrimaryIdentifier]]: "UTC" } ».
2. Let identifiers be the List of unique available named time zone identifiers, sorted according to lexicographic code unit order.
3. Let result be a new empty List.
4. For each element identifier of identifiers, do
   1. Let primary be identifier.
   2. If identifier is a non-primary time zone identifier in this implementation and identifier is not "UTC", then
      1. Set primary to the primary time zone identifier associated with identifier.
      2. NOTE: An implementation may need to resolve identifier iteratively to obtain the primary time zone identifier.
   3. Let record be the Time Zone Identifier Record { [[Identifier]]: identifier, [[PrimaryIdentifier]]: primary }.
   4. Append record to result.
5. Assert: result contains a Time Zone Identifier Record record such that record.[[Identifier]] is "UTC" and record.[[PrimaryIdentifier]] is "UTC".
6. Return result.

The implementation-defined abstract operation SystemTimeZoneIdentifier takes no arguments and returns a String. It returns a String representing the host environment's current time zone, which is either a String representing a UTC offset for which IsTimeZoneOffsetString returns true, or a primary time zone identifier. It performs the following steps when called:

1. If the implementation only supports the UTC time zone, return "UTC".
2. Let systemTimeZoneString be the String representing the host environment's current time zone, either a primary time zone identifier or an offset time zone identifier.
3. Return systemTimeZoneString.

Note

To ensure the level of functionality that implementations commonly provide in the methods of the Date object, it is recommended that SystemTimeZoneIdentifier return an IANA time zone name corresponding to the host environment's time zone setting, if such a thing exists. GetNamedTimeZoneEpochNanoseconds and GetNamedTimeZoneOffsetNanoseconds must reflect the local political rules for standard time and daylight saving time in that time zone, if such rules exist.

For example, if the host environment is a browser on a system where the user has chosen US Eastern Time as their time zone, SystemTimeZoneIdentifier returns "America/New_York".

The abstract operation LocalTime takes argument tv (a finite time value) and returns an integral Number. It converts tv from UTC to local time. The local political rules for standard time and daylight saving time in effect at tv should be used to determine the result in the way specified in this section. It performs the following steps when called:

1. Let systemTimeZoneIdentifier be SystemTimeZoneIdentifier().
2. If IsTimeZoneOffsetString(systemTimeZoneIdentifier) is true, then
   1. Let offsetNs be ParseTimeZoneOffsetString(systemTimeZoneIdentifier).
3. Else,
   1. Let offsetNs be GetNamedTimeZoneOffsetNanoseconds(systemTimeZoneIdentifier, ℤ(ℝ(tv) × 10⁶)).
4. Let offsetMs be truncate(offsetNs / 10⁶).
5. Return tv + 𝔽(offsetMs).

Note 1

If political rules for the local time tv are not available within the implementation, the result is tv because SystemTimeZoneIdentifier returns "UTC" and GetNamedTimeZoneOffsetNanoseconds returns 0.

Note 2

It is required for time zone aware implementations (and recommended for all others) to use the time zone information of the IANA Time Zone Database https://www.iana.org/time-zones/.

Note 3

Two different input time values tv_UTC are converted to the same local time t_local at a negative time zone transition when there are repeated times (e.g. the daylight saving time ends or the time zone adjustment is decreased.).

LocalTime(UTC(tv_local)) is not necessarily always equal to tv_local. Correspondingly, UTC(LocalTime(tv_UTC)) is not necessarily always equal to tv_UTC.

The abstract operation UTC takes argument t (a Number) and returns a time value. It converts t from local time to a UTC time value. The local political rules for standard time and daylight saving time in effect at t should be used to determine the result in the way specified in this section. It performs the following steps when called:

1. If t is not finite, return NaN.
2. Let systemTimeZoneIdentifier be SystemTimeZoneIdentifier().
3. If IsTimeZoneOffsetString(systemTimeZoneIdentifier) is true, then
   1. Let offsetNs be ParseTimeZoneOffsetString(systemTimeZoneIdentifier).
4. Else,
   1. Let possibleInstants be GetNamedTimeZoneEpochNanoseconds(systemTimeZoneIdentifier, ℝ(YearFromTime(t)), ℝ(MonthFromTime(t)) + 1, ℝ(DateFromTime(t)), ℝ(HourFromTime(t)), ℝ(MinFromTime(t)), ℝ(SecFromTime(t)), ℝ(msFromTime(t)), 0, 0).
   2. NOTE: The following steps ensure that when t represents local time repeating multiple times at a negative time zone transition (e.g. when the daylight saving time ends or the time zone offset is decreased due to a time zone rule change) or skipped local time at a positive time zone transition (e.g. when the daylight saving time starts or the time zone offset is increased due to a time zone rule change), t is interpreted using the time zone offset before the transition.
   3. If possibleInstants is not empty, then
      1. Let disambiguatedInstant be possibleInstants[0].
   4. Else,
      1. NOTE: t represents a local time skipped at a positive time zone transition (e.g. due to daylight saving time starting or a time zone rule change increasing the UTC offset).
      2. Let possibleInstantsBefore be GetNamedTimeZoneEpochNanoseconds(systemTimeZoneIdentifier, ℝ(YearFromTime(tBefore)), ℝ(MonthFromTime(tBefore)) + 1, ℝ(DateFromTime(tBefore)), ℝ(HourFromTime(tBefore)), ℝ(MinFromTime(tBefore)), ℝ(SecFromTime(tBefore)), ℝ(msFromTime(tBefore)), 0, 0), where tBefore is the largest integral Number < t for which possibleInstantsBefore is not empty (i.e., tBefore represents the last local time before the transition).
      3. Let disambiguatedInstant be the last element of possibleInstantsBefore.
   5. Let offsetNs be GetNamedTimeZoneOffsetNanoseconds(systemTimeZoneIdentifier, disambiguatedInstant).
5. Let offsetMs be truncate(offsetNs / 10⁶).
6. Return t - 𝔽(offsetMs).

Input t is nominally a time value but may be any Number value. The algorithm must not limit t to the time value range, so that inputs corresponding with a boundary of the time value range can be supported regardless of local UTC offset. For example, the maximum time value is 8.64 × 10¹⁵, corresponding with "+275760-09-13T00:00:00Z". In an environment where the local time zone offset is ahead of UTC by 1 hour at that instant, it is represented by the larger input of 8.64 × 10¹⁵ + 3.6 × 10⁶, corresponding with "+275760-09-13T01:00:00+01:00".

If political rules for the local time t are not available within the implementation, the result is t because SystemTimeZoneIdentifier returns "UTC" and GetNamedTimeZoneOffsetNanoseconds returns 0.

Note 1

It is required for time zone aware implementations (and recommended for all others) to use the time zone information of the IANA Time Zone Database https://www.iana.org/time-zones/.

1:30 AM on 5 November 2017 in America/New_York is repeated twice (fall backward), but it must be interpreted as 1:30 AM UTC-04 instead of 1:30 AM UTC-05. In UTC(TimeClip(MakeDate(MakeDay(2017, 10, 5), MakeTime(1, 30, 0, 0)))), the value of offsetMs is -4 × msPerHour.

2:30 AM on 12 March 2017 in America/New_York does not exist, but it must be interpreted as 2:30 AM UTC-05 (equivalent to 3:30 AM UTC-04). In UTC(TimeClip(MakeDate(MakeDay(2017, 2, 12), MakeTime(2, 30, 0, 0)))), the value of offsetMs is -5 × msPerHour.

Note 2

UTC(LocalTime(t_UTC)) is not necessarily always equal to t_UTC. Correspondingly, LocalTime(UTC(t_local)) is not necessarily always equal to t_local.

The abstract operation MakeTime takes arguments hour (a Number), min (a Number), sec (a Number), and ms (a Number) and returns a Number. It calculates a number of milliseconds. It performs the following steps when called:

1. If hour is not finite, min is not finite, sec is not finite, or ms is not finite, return NaN.
2. Let h be 𝔽(! ToIntegerOrInfinity(hour)).
3. Let m be 𝔽(! ToIntegerOrInfinity(min)).
4. Let s be 𝔽(! ToIntegerOrInfinity(sec)).
5. Let milli be 𝔽(! ToIntegerOrInfinity(ms)).
6. Return ((h × msPerHour + m × msPerMinute) + s × msPerSecond) + milli.

Note

The arithmetic in MakeTime is floating-point arithmetic, which is not associative, so the operations must be performed in the correct order.

The abstract operation MakeDay takes arguments year (a Number), month (a Number), and date (a Number) and returns a finite Number or NaN. It calculates a number of days. It performs the following steps when called:

1. If year is not finite, month is not finite, or date is not finite, return NaN.
2. Let y be 𝔽(! ToIntegerOrInfinity(year)).
3. Let m be 𝔽(! ToIntegerOrInfinity(month)).
4. Let dt be 𝔽(! ToIntegerOrInfinity(date)).
5. Let ym be y + 𝔽(floor(ℝ(m) / 12)).
6. If ym is not finite, return NaN.
7. Let mn be 𝔽(ℝ(m) modulo 12).
8. Find a finite time value tv such that YearFromTime(tv) is ym, MonthFromTime(tv) is mn, and DateFromTime(tv) is 1_𝔽; but if this is not possible (because some argument is out of range), return NaN.
9. Return Day(tv) + dt - 1_𝔽.

The abstract operation MakeDate takes arguments day (a Number) and time (a Number) and returns a finite Number or NaN. It calculates a number of milliseconds. It performs the following steps when called:

1. If day is not finite or time is not finite, return NaN.
2. Let tv be day × msPerDay + time.
3. If tv is not finite, return NaN.
4. Return tv.

The abstract operation MakeFullYear takes argument year (a Number) and returns an integral Number or NaN. It returns the full year associated with the integer part of year, interpreting any value in the inclusive interval from 0 to 99 as a count of years since the start of 1900. For alignment with the proleptic Gregorian calendar, “full year” is defined as the signed count of complete years since the start of year 0 (1 B.C.). It performs the following steps when called:

1. If year is one of NaN, +∞_𝔽, or -∞_𝔽, return NaN.
2. Let truncated be ! ToIntegerOrInfinity(year).
3. If truncated is in the inclusive interval from 0 to 99, return 1900_𝔽 + 𝔽(truncated).
4. Return 𝔽(truncated).

The abstract operation TimeClip takes argument time (a Number) and returns a time value. It calculates a number of milliseconds. It performs the following steps when called:

1. If time is not finite, return NaN.
2. If abs(ℝ(time)) > 8.64 × 10¹⁵, return NaN.
3. Return 𝔽(! ToIntegerOrInfinity(time)).

ECMAScript defines a string interchange format for date-times based upon a simplification of the ISO 8601 calendar date extended format. The format is as follows: YYYY-MM-DDTHH:mm:ss.sssZ

Where the elements are as follows:

YYYY	is the year in the proleptic Gregorian calendar as four decimal digits from 0000 to 9999, or as an expanded year of "+" or "-" followed by six decimal digits.
-	"-" (hyphen) appears literally twice in the string.
MM	is the month of the year as two decimal digits from 01 (January) to 12 (December).
DD	is the day of the month as two decimal digits from 01 to 31.
T	"T" appears literally in the string, to indicate the beginning of the time element.
HH	is the number of complete hours that have passed since midnight as two decimal digits from 00 to 24.
:	":" (colon) appears literally twice in the string.
mm	is the number of complete minutes since the start of the hour as two decimal digits from 00 to 59.
ss	is the number of complete seconds since the start of the minute as two decimal digits from 00 to 59.
.	"." (dot) appears literally in the string.
sss	is the number of complete milliseconds since the start of the second as three decimal digits.
Z	is the UTC offset representation specified as "Z" (for UTC with no offset) or as either "+" or "-" followed by a time expression HH:mm (a subset of the time zone offset string format for indicating local time ahead of or behind UTC, respectively)

This format includes date-only forms:

YYYY
YYYY-MM
YYYY-MM-DD
        

It also includes “date-time” forms that consist of one of the above date-only forms immediately followed by one of the following time forms with an optional UTC offset representation appended:

THH:mm
THH:mm:ss
THH:mm:ss.sss
        

A string containing out-of-bounds or nonconforming elements is not a valid instance of this format.

Note 1

As every day both starts and ends with midnight, the two notations 00:00 and 24:00 are available to distinguish the two midnights that can be associated with one date. This means that the following two notations refer to exactly the same point in time: 1995-02-04T24:00 and 1995-02-05T00:00. This interpretation of the latter form as “end of a calendar day” is consistent with ISO 8601, even though that specification reserves it for describing time intervals and does not permit it within representations of single points in time.

Note 2

There exists no international standard that specifies abbreviations for civil time zones like CET, EST, etc. and sometimes the same abbreviation is even used for two very different time zones. For this reason, both ISO 8601 and this format specify numeric representations of time zone offsets.

ECMAScript defines a string interchange format for UTC offsets, derived from ISO 8601. The format is described by the following grammar.

Syntax

UTCOffset ::: ASCIISign Hour ASCIISign Hour HourSubcomponents[+Extended] ASCIISign Hour HourSubcomponents[~Extended] ASCIISign ::: one of + - Hour ::: 0 DecimalDigit 1 DecimalDigit 20 21 22 23 HourSubcomponents[Extended] ::: TimeSeparator[?Extended] MinuteSecond TimeSeparator[?Extended] MinuteSecond TimeSeparator[?Extended] MinuteSecond TemporalDecimalFractionopt TimeSeparator[Extended] ::: [+Extended] : [~Extended] [empty] MinuteSecond ::: 0 DecimalDigit 1 DecimalDigit 2 DecimalDigit 3 DecimalDigit 4 DecimalDigit 5 DecimalDigit TemporalDecimalFraction ::: TemporalDecimalSeparator DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit DecimalDigit TemporalDecimalSeparator ::: one of . ,

This function performs the following steps when called:

1. If NewTarget is undefined, then
   1. Let now be the time value (UTC) identifying the current time.
   2. Return ToDateString(now).
2. Let numberOfArgs be the number of elements in values.
3. If numberOfArgs = 0, then
   1. Let dv be the time value (UTC) identifying the current time.
4. Else if numberOfArgs = 1, then
   1. Let value be values[0].
   2. If value is an Object and value has a [[DateValue]] internal slot, then
      1. Let tv be value.[[DateValue]].
   3. Else,
      1. Let v be ? ToPrimitive(value).
      2. If v is a String, then
         1. Assert: The next step never returns an abrupt completion because v is a String.
         2. Let tv be the result of parsing v as a date, in exactly the same manner as for the parse method (21.4.3.2).
      3. Else,
         1. Let tv be ? ToNumber(v).
   4. Let dv be TimeClip(tv).
5. Else,
   1. Assert: numberOfArgs ≥ 2.
   2. Let y be ? ToNumber(values[0]).
   3. Let m be ? ToNumber(values[1]).
   4. If numberOfArgs > 2, let dt be ? ToNumber(values[2]); else let dt be 1_𝔽.
   5. If numberOfArgs > 3, let h be ? ToNumber(values[3]); else let h be +0_𝔽.
   6. If numberOfArgs > 4, let min be ? ToNumber(values[4]); else let min be +0_𝔽.
   7. If numberOfArgs > 5, let s be ? ToNumber(values[5]); else let s be +0_𝔽.
   8. If numberOfArgs > 6, let milli be ? ToNumber(values[6]); else let milli be +0_𝔽.
   9. Let yr be MakeFullYear(y).
   10. Let finalDate be MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli)).
   11. Let dv be TimeClip(UTC(finalDate)).
6. Let obj be ? OrdinaryCreateFromConstructor(NewTarget, "%Date.prototype%", « [[DateValue]] »).
7. Set obj.[[DateValue]] to dv.
8. Return obj.

This function returns the time value designating the UTC date and time of the occurrence of the call to it.

This function applies the ToString operator to its argument. If ToString results in an abrupt completion the Completion Record is immediately returned. Otherwise, this function interprets the resulting String as a date and time; it returns a Number, the UTC time value corresponding to the date and time. The String may be interpreted as a local time, a UTC time, or a time in some other time zone, depending on the contents of the String. The function first attempts to parse the String according to the format described in Date Time String Format (21.4.1.32), including expanded years. If the String does not conform to that format the function may fall back to any implementation-specific heuristics or implementation-specific date formats. Strings that are unrecognizable or contain out-of-bounds format element values shall cause this function to return NaN.

If the String conforms to the Date Time String Format, substitute values take the place of absent format elements. When the MM or DD elements are absent, "01" is used. When the HH, mm, or ss elements are absent, "00" is used. When the sss element is absent, "000" is used. When the UTC offset representation is absent, date-only forms are interpreted as a UTC time and date-time forms are interpreted as a local time.

If x is any Date whose milliseconds amount is zero within a particular implementation of ECMAScript, then all of the following expressions should produce the same numeric value in that implementation, if all the properties referenced have their initial values:

          x.valueOf()
          Date.parse(x.toString())
          Date.parse(x.toUTCString())
          Date.parse(x.toISOString())
        

However, the expression

          Date.parse(x.toLocaleString())
        

is not required to produce the same Number value as the preceding three expressions and, in general, the value produced by this function is implementation-defined when given any String value that does not conform to the Date Time String Format (21.4.1.32) and that could not be produced in that implementation by the toString or toUTCString method.

The initial value of Date.prototype is the Date prototype object.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

This function performs the following steps when called:

1. Let y be ? ToNumber(year).
2. If month is present, let m be ? ToNumber(month); else let m be +0_𝔽.
3. If date is present, let dt be ? ToNumber(date); else let dt be 1_𝔽.
4. If hours is present, let h be ? ToNumber(hours); else let h be +0_𝔽.
5. If minutes is present, let min be ? ToNumber(minutes); else let min be +0_𝔽.
6. If seconds is present, let s be ? ToNumber(seconds); else let s be +0_𝔽.
7. If ms is present, let milli be ? ToNumber(ms); else let milli be +0_𝔽.
8. Let yr be MakeFullYear(y).
9. Return TimeClip(MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli))).

The "length" property of this function is 7_𝔽.

Note

This function differs from the Date constructor in two ways: it returns a time value as a Number, rather than creating a Date, and it interprets the arguments in UTC rather than as local time.

The initial value of Date.prototype.constructor is %Date%.

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return DateFromTime(LocalTime(tv)).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return WeekDay(LocalTime(tv)).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return YearFromTime(LocalTime(tv)).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return HourFromTime(LocalTime(tv)).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return msFromTime(LocalTime(tv)).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return MinFromTime(LocalTime(tv)).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return MonthFromTime(LocalTime(tv)).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return SecFromTime(LocalTime(tv)).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Return dateObj.[[DateValue]].

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return (tv - LocalTime(tv)) / msPerMinute.

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return DateFromTime(tv).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return WeekDay(tv).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return YearFromTime(tv).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return HourFromTime(tv).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return msFromTime(tv).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return MinFromTime(tv).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return MonthFromTime(tv).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. If tv is NaN, return NaN.
5. Return SecFromTime(tv).

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. Let dt be ? ToNumber(date).
5. If tv is NaN, return NaN.
6. Set tv to LocalTime(tv).
7. Let newDate be MakeDate(MakeDay(YearFromTime(tv), MonthFromTime(tv), dt), TimeWithinDay(tv)).
8. Let u be TimeClip(UTC(newDate)).
9. Set dateObj.[[DateValue]] to u.
10. Return u.

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. Let y be ? ToNumber(year).
5. If tv is NaN, set tv to +0_𝔽; else set tv to LocalTime(tv).
6. If month is present, let m be ? ToNumber(month); else let m be MonthFromTime(tv).
7. If date is present, let dt be ? ToNumber(date); else let dt be DateFromTime(tv).
8. Let newDate be MakeDate(MakeDay(y, m, dt), TimeWithinDay(tv)).
9. Let u be TimeClip(UTC(newDate)).
10. Set dateObj.[[DateValue]] to u.
11. Return u.

The "length" property of this method is 3_𝔽.

Note

If month is not present, this method behaves as if month was present with the value getMonth(). If date is not present, it behaves as if date was present with the value getDate().

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. Let h be ? ToNumber(hour).
5. If min is present, let m be ? ToNumber(min).
6. If sec is present, let s be ? ToNumber(sec).
7. If ms is present, let milli be ? ToNumber(ms).
8. If tv is NaN, return NaN.
9. Set tv to LocalTime(tv).
10. If min is not present, let m be MinFromTime(tv).
11. If sec is not present, let s be SecFromTime(tv).
12. If ms is not present, let milli be msFromTime(tv).
13. Let date be MakeDate(Day(tv), MakeTime(h, m, s, milli)).
14. Let u be TimeClip(UTC(date)).
15. Set dateObj.[[DateValue]] to u.
16. Return u.

The "length" property of this method is 4_𝔽.

Note

If min is not present, this method behaves as if min was present with the value getMinutes(). If sec is not present, it behaves as if sec was present with the value getSeconds(). If ms is not present, it behaves as if ms was present with the value getMilliseconds().

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. Set ms to ? ToNumber(ms).
5. If tv is NaN, return NaN.
6. Set tv to LocalTime(tv).
7. Let time be MakeTime(HourFromTime(tv), MinFromTime(tv), SecFromTime(tv), ms).
8. Let u be TimeClip(UTC(MakeDate(Day(tv), time))).
9. Set dateObj.[[DateValue]] to u.
10. Return u.

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. Let m be ? ToNumber(min).
5. If sec is present, let s be ? ToNumber(sec).
6. If ms is present, let milli be ? ToNumber(ms).
7. If tv is NaN, return NaN.
8. Set tv to LocalTime(tv).
9. If sec is not present, let s be SecFromTime(tv).
10. If ms is not present, let milli be msFromTime(tv).
11. Let date be MakeDate(Day(tv), MakeTime(HourFromTime(tv), m, s, milli)).
12. Let u be TimeClip(UTC(date)).
13. Set dateObj.[[DateValue]] to u.
14. Return u.

The "length" property of this method is 3_𝔽.

Note

If sec is not present, this method behaves as if sec was present with the value getSeconds(). If ms is not present, this behaves as if ms was present with the value getMilliseconds().

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. Let m be ? ToNumber(month).
5. If date is present, let dt be ? ToNumber(date).
6. If tv is NaN, return NaN.
7. Set tv to LocalTime(tv).
8. If date is not present, let dt be DateFromTime(tv).
9. Let newDate be MakeDate(MakeDay(YearFromTime(tv), m, dt), TimeWithinDay(tv)).
10. Let u be TimeClip(UTC(newDate)).
11. Set dateObj.[[DateValue]] to u.
12. Return u.

The "length" property of this method is 2_𝔽.

Note

If date is not present, this method behaves as if date was present with the value getDate().

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. Let s be ? ToNumber(sec).
5. If ms is present, let milli be ? ToNumber(ms).
6. If tv is NaN, return NaN.
7. Set tv to LocalTime(tv).
8. If ms is not present, let milli be msFromTime(tv).
9. Let date be MakeDate(Day(tv), MakeTime(HourFromTime(tv), MinFromTime(tv), s, milli)).
10. Let u be TimeClip(UTC(date)).
11. Set dateObj.[[DateValue]] to u.
12. Return u.

The "length" property of this method is 2_𝔽.

Note

If ms is not present, this method behaves as if ms was present with the value getMilliseconds().

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let t be ? ToNumber(time).
4. Let v be TimeClip(t).
5. Set dateObj.[[DateValue]] to v.
6. Return v.

This method performs the following steps when called:

1. Let dateObj be the this value.
2. Perform ? RequireInternalSlot(dateObj, [[DateValue]]).
3. Let tv be dateObj.[[DateValue]].
4. Let dt be ? ToNumber(date).
5. If tv is NaN, return NaN.
6. Let newDate be MakeDate(MakeDay(YearFromTime(tv), MonthFromTime(tv), dt), TimeWithinDay(tv)).
7. Let v be TimeClip(newDate).
8. Set dateObj.[[DateValue]] to v.
9. Return v.