4.2.1 Objects

ECMAScript does not use classes such as those in C++, Smalltalk, or Java. Instead objects may be created in various ways including via a literal notation or via constructors which create objects and then execute code that initialises all or part of them by assigning initial values to their properties. Each constructor is a function that has a property named “prototype” that is used to implement prototype-based inheritance and shared properties. Objects are created by using constructors in new expressions; for example, new Date(2009,11) creates a new Date object. Invoking a constructor without using new has consequences that depend on the constructor. For example, Date() produces a string representation of the current date and time rather than an object.

Every object created by a constructor has an implicit reference (called the object’s prototype) to the value of its constructor’s “prototype” property. Furthermore, a prototype may have a non-null implicit reference to its prototype, and so on; this is called the prototype chain. When a reference is made to a property in an object, that reference is to the property of that name in the first object in the prototype chain that contains a property of that name. In other words, first the object mentioned directly is examined for such a property; if that object contains the named property, that is the property to which the reference refers; if that object does not contain the named property, the prototype for that object is examined next; and so on.

In a class-based object-oriented language, in general, state is carried by instances, methods are carried by classes, and inheritance is only of structure and behaviour. In ECMAScript, the state and methods are carried by objects, while structure, behaviour, and state are all inherited.

All objects that do not directly contain a particular property that their prototype contains share that property and its value. Figure 1 illustrates this:

CF is a constructor (and also an object). Five objects have been created by using new expressions: cf₁, cf₂, cf₃, cf₄, and cf₅. Each of these objects contains properties named q1 and q2. The dashed lines represent the implicit prototype relationship; so, for example, cf₃’s prototype is CF_p. The constructor, CF, has two properties itself, named P1 and P2, which are not visible to CF_p, cf₁, cf₂, cf₃, cf₄, or cf₅. The property named CFP1 in CF_p is shared by cf₁, cf₂, cf₃, cf₄, and cf₅ (but not by CF), as are any properties found in CF_p’s implicit prototype chain that are not named q1, q2, or CFP1. Notice that there is no implicit prototype link between CF and CF_p.

Unlike class-based object languages, properties can be added to objects dynamically by assigning values to them. That is, constructors are not required to name or assign values to all or any of the constructed object’s properties. In the above diagram, one could add a new shared property for cf₁, cf₂, cf₃, cf₄, and cf₅ by assigning a new value to the property in CF_p.

4.2.2 The Strict Variant of ECMAScript

The ECMAScript Language recognises the possibility that some users of the language may wish to restrict their usage of some features available in the language. They might do so in the interests of security, to avoid what they consider to be error-prone features, to get enhanced error checking, or for other reasons of their choosing. In support of this possibility, ECMAScript defines a strict variant of the language. The strict variant of the language excludes some specific syntactic and semantic features of the regular ECMAScript language and modifies the detailed semantics of some features. The strict variant also specifies additional error conditions that must be reported by throwing error exceptions in situations that are not specified as errors by the non-strict form of the language.

The strict variant of ECMAScript is commonly referred to as the strict mode of the language. Strict mode selection and use of the strict mode syntax and semantics of ECMAScript is explicitly made at the level of individual ECMAScript code units. Because strict mode is selected at the level of a syntactic code unit, strict mode only imposes restrictions that have local effect within such a code unit. Strict mode does not restrict or modify any aspect of the ECMAScript semantics that must operate consistently across multiple code units. A complete ECMAScript program may be composed for both strict mode and non-strict mode ECMAScript code units. In this case, strict mode only applies when actually executing code that is defined within a strict mode code unit.

In order to conform to this specification, an ECMAScript implementation must implement both the full unrestricted ECMAScript language and the strict mode variant of the ECMAScript language as defined by this specification. In addition, an implementation must support the combination of unrestricted and strict mode code units into a single composite program.

4.3.1 type

set of data values as defined in clause 6 of this specification

4.3.2 primitive value

member of one of the types Undefined, Null, Boolean, Number, Symbol, or String as defined in clause 6

4.3.3 object

member of the type Object

4.3.4 constructor

function object that creates and initialises objects

4.3.5 prototype

object that provides shared properties for other objects

4.3.6 ordinary object

object that has the default behaviour for the essential internal methods that must be supported by all objects.

4.3.7 exotic object

object that has some alternative behaviour for one or more of the essential internal methods that must be supported by all objects.

4.3.8 standard object

object whose semantics are defined by this specification.

4.3.9 built-in object

object supplied by an ECMAScript implementation, independent of the host environment, that is present at the start of the execution of an ECMAScript program

4.3.10 undefined value

primitive value used when a variable has not been assigned a value

4.3.11 Undefined type

type whose sole value is the undefined value

4.3.12 null value

primitive value that represents the intentional absence of any object value

4.3.13 Null type

type whose sole value is the null value

4.3.14 Boolean value

member of the Boolean type

4.3.15 Boolean type

type consisting of the primitive values true and false

4.3.16 Boolean object

member of the Object type that is an instance of the standard built-in Boolean constructor

4.3.17 String value

primitive value that is a finite ordered sequence of zero or more 16-bit unsigned integer

4.3.18 String type

set of all possible String values

4.3.19 String object

member of the Object type that is an instance of the standard built-in String constructor

4.3.20 Number value

primitive value corresponding to a double-precision 64-bit binary format IEEE 754 value

4.3.21 Number type

set of all possible Number values including the special “Not-a-Number” (NaN) value, positive infinity, and negative infinity

4.3.22 Number object

member of the Object type that is an instance of the standard built-in Number constructor

4.3.23 Infinity

number value that is the positive infinite Number value

4.3.24 NaN

number value that is an IEEE 754 “Not-a-Number” value

4.3.26 Symbol type

set of all possible Symbol values

4.3.27 Symbol object

member of the Object type that is an instance of the standard built-in Symbol constructor

4.3.28 function

member of the Object type that may be invoked as a subroutine

4.3.29 built-in function

built-in object that is a function

4.3.30 property

association between a key and a value that is a part of an object. The key be either a String value or a Symbol value.

4.3.31 method

function that is the value of a property

4.3.32 built-in method

method that is a built-in function

4.3.33 attribute

internal value that defines some characteristic of a property

4.3.34 own property

property that is directly contained by its object

4.3.35 inherited property

property of an object that is not an own property but is a property (either own or inherited) of the object’s prototype

5.1.1 Context-Free Grammars

A context-free grammar consists of a number of productions. Each production has an abstract symbol called a nonterminal as its left-hand side, and a sequence of zero or more nonterminal and terminal symbols as its right-hand side. For each grammar, the terminal symbols are drawn from a specified alphabet.

A chain production is a production that has exactly one nonterminal symbol on its right-hand side along with zero or more terminal symbols.

Starting from a sentence consisting of a single distinguished nonterminal, called the goal symbol, a given context-free grammar specifies a language, namely, the (perhaps infinite) set of possible sequences of terminal symbols that can result from repeatedly replacing any nonterminal in the sequence with a right-hand side of a production for which the nonterminal is the left-hand side.

5.1.2 The Lexical and RegExp Grammars

A lexical grammar for ECMAScript is given in clause 11. This grammar has as its terminal symbols characters (Unicode code units) that conform to the rules for SourceCharacter defined in clause 10.1. It defines a set of productions, starting from the goal symbol InputElementDiv or InputElementRegExp, that describe how sequences of such characters are translated into a sequence of input elements.

Input elements other than white space and comments form the terminal symbols for the syntactic grammar for ECMAScript and are called ECMAScript tokens. These tokens are the reserved words, identifiers, literals, and punctuators of the ECMAScript language. Moreover, line terminators, although not considered to be tokens, also become part of the stream of input elements and guide the process of automatic semicolon insertion (11.9). Simple white space and single-line comments are discarded and do not appear in the stream of input elements for the syntactic grammar. A MultiLineComment (that is, a comment of the form “/*…*/” regardless of whether it spans more than one line) is likewise simply discarded if it contains no line terminator; but if a MultiLineComment contains one or more line terminators, then it is replaced by a single line terminator, which becomes part of the stream of input elements for the syntactic grammar.

A RegExp grammar for ECMAScript is given in 21.2.1. This grammar also has as its terminal symbols the characters as defined by SourceCharacter. It defines a set of productions, starting from the goal symbol Pattern, that describe how sequences of characters are translated into regular expression patterns.

Productions of the lexical and RegExp grammars are distinguished by having two colons “::” as separating punctuation. The lexical and RegExp grammars share some productions.

5.1.3 The Numeric String Grammar

Another grammar is used for translating Strings into numeric values. This grammar is similar to the part of the lexical grammar having to do with numeric literals and has as its terminal symbols SourceCharacter. This grammar appears in 7.1.3.1.

Productions of the numeric string grammar are distinguished by having three colons “:::” as punctuation.

5.1.4 The Syntactic Grammar

The syntactic grammar for ECMAScript is given in clauses 11, 12, 13 and 14. This grammar has ECMAScript tokens defined by the lexical grammar as its terminal symbols (5.1.2). It defines a set of productions, starting from the goal symbol Script, that describe how sequences of tokens can form syntactically correct independent components of an ECMAScript programs.

When a stream of characters is to be parsed as an ECMAScript script, it is first converted to a stream of input elements by repeated application of the lexical grammar; this stream of input elements is then parsed by a single application of the syntactic grammar. The script is syntactically in error if the tokens in the stream of input elements cannot be parsed as a single instance of the goal nonterminal Script, with no tokens left over.

Productions of the syntactic grammar are distinguished by having just one colon “:” as punctuation.

The syntactic grammar as presented in clauses 12, 13, 14 and 15 is actually not a complete account of which token sequences are accepted as correct ECMAScript scripts. Certain additional token sequences are also accepted, namely, those that would be described by the grammar if only semicolons were added to the sequence in certain places (such as before line terminator characters). Furthermore, certain token sequences that are described by the grammar are not considered acceptable if a terminator character appears in certain “awkward” places.

In certain cases in order to avoid ambiguities the syntactic grammar uses generalised productions that permit token sequences that are not valid ECMAScript scripts. For example, this technique is used in with object literals and object destructuring patterns. In such cases a more restrictive supplemental grammar is provided that further restricts the acceptable token sequences. In certain contexts, when explicitly specific, the input elements corresponding to such a production are parsed again using a goal symbol of a supplemental grammar. The script is syntactically in error if the tokens in the stream of input elements cannot be parsed as a single instance of the supplemental goal symbol, with no tokens left over.

5.1.5 Grammar Notation

Terminal symbols of the lexical, RegExp, and numeric string grammars, and some of the terminal symbols of the other grammars, are shown in fixed width font, both in the productions of the grammars and throughout this specification whenever the text directly refers to such a terminal symbol. These are to appear in a script either exactly as written. All terminal symbol characters specified in this way are to be understood as the appropriate Unicode code points from the Basic Latin range, as opposed to any similar-looking characters from other Unicode ranges.

Nonterminal symbols are shown in italic type. The definition of a nonterminal (also called a “production”) is introduced by the name of the nonterminal being defined followed by one or more colons. (The number of colons indicates to which grammar the production belongs.) One or more alternative right-hand sides for the nonterminal then follow on succeeding lines. For example, the syntactic definition:

states that the nonterminal WhileStatement represents the token while, followed by a left parenthesis token, followed by an Expression, followed by a right parenthesis token, followed by a Statement. The occurrences of Expression and Statement are themselves nonterminals. As another example, the syntactic definition:

states that an ArgumentList may represent either a single AssignmentExpression or an ArgumentList, followed by a comma, followed by an AssignmentExpression. This definition of ArgumentList is recursive, that is, it is defined in terms of itself. The result is that an ArgumentList may contain any positive number of arguments, separated by commas, where each argument expression is an AssignmentExpression. Such recursive definitions of nonterminals are common.

The subscripted suffix “_opt”, which may appear after a terminal or nonterminal, indicates an optional symbol. The alternative containing the optional symbol actually specifies two right-hand sides, one that omits the optional element and one that includes it. This means that:

is a convenient abbreviation for:

and that:

is a convenient abbreviation for:

which in turn is an abbreviation for:

so, in this example, the nonterminal IterationStatement actually has four alternative right-hand sides.

A production may be parameterised by a subscripted annotation of the form “_[parameters]”, which may appear as a suffix to the nonterminal symbol defined by the production. “_parameters” may be either a single name or a comma separated list of names. A parameterised production is a shorthand for a set of productions defining all combinations of the parameter names appended to the parameterised nonterminal symbol. This means that:

is a convenient abbreviation for:

and that:

is abbreviation for:

References to nonterminals on the right hand side of a production can also be parameterised. For example:

is equivalent to saying:

A nonterminal reference may have both a parameter list and an “_opt” suffix. For example:

is an abbreviation for:

Prefixing a parameter name with “_?”on a right hand side nonterminal reference makes that parameter value dependent upon the occurrence of the parameter name on the reference to the current production’s left hand side symbol. For example:

is an abbreviation for:

If a right hand side alternative is prefixed with “[+parameter]” that alternative is only available if the named parameter was used in referencing the production’s nonterminal symbol. If a right hand side alternative is prefixed with “[~parameter]” that alternative is only available if the named parameter was not used in referencing the production’s nonterminal symbol. This means that:

is an abbreviation for:

and that

is an abbreviation for:

When the words “one of” follow the colon(s) in a grammar definition, they signify that each of the terminal symbols on the following line or lines is an alternative definition. For example, the lexical grammar for ECMAScript contains the production:

which is merely a convenient abbreviation for:

If the phrase “[empty]” appears as the right-hand side of a production, it indicates that the production's right-hand side contains no terminals or nonterminals.

If the phrase “[lookahead ∉ set]” appears in the right-hand side of a production, it indicates that the production may not be used if the immediately following input token is a member of the given set. The set can be written as a list of terminals enclosed in curly braces. For convenience, the set can also be written as a nonterminal, in which case it represents the set of all terminals to which that nonterminal could expand. For example, given the definitions

the definition

matches either the letter n followed by one or more decimal digits the first of which is even, or a decimal digit not followed by another decimal digit.

If the phrase “[no LineTerminator here]” appears in the right-hand side of a production of the syntactic grammar, it indicates that the production is a restricted production: it may not be used if a LineTerminator occurs in the input stream at the indicated position. For example, the production:

indicates that the production may not be used if a LineTerminator occurs in the script between the throw token and the Expression.

Unless the presence of a LineTerminator is forbidden by a restricted production, any number of occurrences of LineTerminator may appear between any two consecutive tokens in the stream of input elements without affecting the syntactic acceptability of the script.

The lexical grammar has multiple goal symbols and the appropriate goal symbol to use depends upon the syntactic grammar context. If a phrase of the form “[Lexical goal LexicalGoalSymbol]” appears on the right-hand-side of a syntactic production then the next token must be lexically recognised using the indicated goal symbol. In the absence of such a phrase the default lexical goal symbol is used.

When an alternative in a production of the lexical grammar or the numeric string grammar appears to be a multi-character token, it represents the sequence of characters that would make up such a token.

The right-hand side of a production may specify that certain expansions are not permitted by using the phrase “but not” and then indicating the expansions to be excluded. For example, the production:

means that the nonterminal Identifier may be replaced by any sequence of characters that could replace IdentifierName provided that the same sequence of characters could not replace ReservedWord.

Finally, a few nonterminal symbols are described by a descriptive phrase in sans-serif type in cases where it would be impractical to list all the alternatives:

6.1.1 The Undefined Type

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

6.1.2 The Null Type

The Null type has exactly one value, called null.

6.1.3 The Boolean Type

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

6.1.4 The String Type

The String type is the set of all finite ordered sequences of zero or more 16-bit unsigned integer values (“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 nonnegative 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.

Where ECMAScript operations interpret String values, each element is interpreted as a single UTF-16 code unit. However, ECMAScript does not place any restrictions or requirements on the sequence of code units in a String value, so they may be ill-formed when interpreted as UTF-16 code unit sequences. Operations that do not interpret String contents treat them as sequences of undifferentiated 16-bit unsigned integers. No operations ensure that Strings are in a normalized form. Only operations that are explicitly specified to be language or locale sensitive produce language-sensitive results

Some operations interpret String contents as UTF-16 encoded Unicode code points. In that case the interpretation is:

• A code unit in the range 0 to 0xD7FF or in the range 0xE000 to 0xFFFF is interpreted as a code point with the same value.

• A sequence of two code units, where the first code unit c1 is in the range 0xD800 to 0xDBFF and the second code unit c2 is in the range 0xDC00 to 0xDFFF, is a surrogate pair and is interpreted as a code point with the value (c1 - 0xD800) × 0x400 + (c2 – 0xDC00) + 0x10000.

• A code unit that is in the range 0xD800 to 0xDFFF, but is not part of a surrogate pair, is interpreted as a code point with the same value.

6.1.6 The Number Type

The Number type has exactly 18437736874454810627 (that is, 2⁶⁴−2⁵³+3) values, representing the double-precision 64-bit format IEEE 754 values as specified in the IEEE Standard for Binary Floating-Point Arithmetic, except that the 9007199254740990 (that is, 2⁵³−2) distinct “Not-a-Number” 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 Not-a-Number values, but such behaviour is implementation-dependent; to ECMAScript code, all NaN values are indistinguishable from each other.

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 18437736874454810624 (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 18437736874454810622 (that is, 2⁶⁴−2⁵³−2) finite nonzero values are of two kinds:

18428729675200069632 (that is, 2⁶⁴−2⁵⁴) of them are normalised, having the form

where s is +1 or −1, m is a positive integer less than 2⁵³ but not less than 2⁵², and e is an integer ranging from −1074 to 971, inclusive.

The remaining 9007199254740990 (that is, 2⁵³−2) values are denormalised, having the form

where s is +1 or −1, m is a positive integer less than 2⁵², 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 (indeed, the integer 0 has two representations, +0 and -0).

A finite number has an odd significand if it is nonzero 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 nonzero 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 is less than zero; 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 “round to nearest” mode.)

Some ECMAScript operators deal only with integers in the range −2³¹ through 2³¹−1, inclusive, or in the range 0 through 2³²−1, inclusive. These operators accept any value of the Number type but first convert each such value to one of 2³² integer values. See the descriptions of the ToInt32 and ToUint32 operators in 7.1.5 and 7.1.6, respectively.

6.2.1 The List and Record Specification Type

The List type is used to explain the evaluation of argument lists (see 12.2.6) 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 convience an array-like syntax can be used to access List elements. For example, arguments[2] is shorthand for saying the 3^th element of the List arguments.

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 either an ECMAScript value or an abstract value represented by a name associated with the Record type. 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 initialised 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}.

6.2.5 The Lexical Environment and Environment Record Specification Types

The Lexical Environment and Environment Record types are used to explain the behaviour of name resolution in nested functions and blocks. These types and the operations upon them are defined in 8.1.

7.1.1 ToPrimitive

The abstract operation ToPrimitive takes an input argument and an optional argument PreferredType. The abstract operation ToPrimitive converts its input argument to a non-Object type. If an object is capable of converting to more than one primitive type, it may use the optional hint PreferredType to favour that type. Conversion occurs according to Table 9:

When the InputType is Object, the following steps are taken:

1. If PreferredType was not passed, let hint be "default".
2. Else if PreferredType is hint String, let hint be "string".
3. Else PreferredType is hint Number, let hint be "number".
4. Let exoticToPrim be the result of Get(argument, @@toPrimitive).
5. ReturnIfAbrupt(exoticToPrim).
6. If exoticToPrim is not undefined, then
   1. If IsCallable(exoticToPrim) is false, then throw a TypeError exception.
   2. Let result be the result of calling the [[Call]] internal method of exoticToPrim, with argument as thisArgument and a List containing hint as argumentsList.
   3. ReturnIfAbrupt(result).
   4. If result is an ECMAScript language value and Type(result) is not Object, then return result.
   5. Else, throw a TypeError exception.
7. If hint is "default" then, let hint be "number".
8. Return the result of OrdinaryToPrimitive(argument,hint).

When the OrdinaryToPrimitive is called with arguments O and hint, the following steps are taken:

1. Assert: Type(O) is Object
2. Assert: Type(hint) is String and its value is either "string" or "number".
3. If hint is "string", then
   1. Let methodNames be the List ( "toString", "valueOf").
4. Else,
   1. Let methodNames be the List ( "valueOf", "toString").
5. For each name in methodNames in List order, do
   1. Let method be the result of Get(O, name).
   2. ReturnIfAbrupt(method).
   3. If IsCallable(method) is true then,
      1. Let result be the result of calling the [[Call]] internal method of method, with O as thisArgument and an empty List as argumentsList.
      2. ReturnIfAbrupt(result).
      3. If Type(result) is not Object, then return result.
6. Throw a TypeError exception.

7.1.2 ToBoolean

The abstract operation ToBoolean converts its argument to a value of type Boolean according to Table 10:

7.1.4 ToInteger

The abstract operation ToInteger converts its argument to an integral numeric value. This abstract operation functions as follows:

1. Let number be the result of calling ToNumber on the input argument.
2. ReturnIfAbrupt(number).
3. If number is NaN, return +0.
4. If number is +0, −0, +∞, or −∞, return number.
5. Return the result of computing sign(number) × floor(abs(number)).

7.1.5 ToInt32: (Signed 32 Bit Integer)

The abstract operation ToInt32 converts its argument to one of 2³² integer values in the range −2³¹ through 2³¹−1, inclusive. This abstract operation functions as follows:

1. Let number be the result of calling ToNumber on the input argument.
2. ReturnIfAbrupt(number).
3. If number is NaN, +0, −0, +∞, or −∞, return +0.
4. Let int be sign(number) × floor(abs(number)).
5. Let int32bit be int modulo 2³².
6. If int32bit ≥ 2³¹, return int32bit − 2³², otherwise return int32bit.

7.1.6 ToUint32: (Unsigned 32 Bit Integer)

The abstract operation ToUint32 converts its argument to one of 2³² integer values in the range 0 through 2³²−1, inclusive. This abstract operation functions as follows:

1. Let number be the result of calling ToNumber on the input argument.
2. ReturnIfAbrupt(number).
3. If number is NaN, +0, −0, +∞, or −∞, return +0.
4. Let int be sign(number) × floor(abs(number)).
5. Let int32bit be int modulo 2³².
6. Return int32bit.

7.1.7 ToInt16: (Signed 16 Bit Integer)

The abstract operation ToInt16 converts its argument to one of 2¹⁶ integer values in the range −32768 through 32767, inclusive. This abstract operation functions as follows:

1. Let number be the result of calling ToNumber on the input argument.
2. ReturnIfAbrupt(number).
3. If number is NaN, +0, −0, +∞, or −∞, return +0.
4. Let int be sign(number) × floor(abs(number)).
5. Let int16bit be int modulo 2¹⁶.
6. If int16bit ≥ 2¹⁵, return int16bit − 2¹⁶, otherwise return int16bit.

7.1.8 ToUint16: (Unsigned 16 Bit Integer)

The abstract operation ToUint16 converts its argument to one of 2¹⁶ integer values in the range 0 through 2¹⁶−1, inclusive. This abstract operation functions as follows:

1. Let number be the result of calling ToNumber on the input argument.
2. ReturnIfAbrupt(number).
3. If number is NaN, +0, −0, +∞, or −∞, return +0.
4. Let int be sign(number) × floor(abs(number)).
5. Let int16bit be int modulo 2¹⁶.
6. Return int16bit.

7.1.9 ToInt8: (Signed 8 Bit Integer)

The abstract operation ToInt8 converts its argument to one of 2⁸ integer values in the range −128 through 127, inclusive. This abstract operation functions as follows:

1. Let number be the result of calling ToNumber on the input argument.
2. ReturnIfAbrupt(number).
3. If number is NaN, +0, −0, +∞, or −∞, return +0.
4. Let int be sign(number) × floor(abs(number)).
5. Let int8bit be int modulo 2⁸.
6. If int8bit ≥ 2⁷, return int8bit − 2⁸, otherwise return int8bit.

7.1.10 ToUint8: (Unsigned 8 Bit Integer)

The abstract operation ToUint8 converts its argument to one of 2⁸ integer values in the range 0 through 255, inclusive. This abstract operation functions as follows:

1. Let number be the result of calling ToNumber on the input argument.
2. ReturnIfAbrupt(number).
3. If number is NaN, +0, −0, +∞, or −∞, return +0.
4. Let int be sign(number) × floor(abs(number)).
5. Let int8bit be int modulo 2⁸.
6. Return int8bit.

7.1.11 ToUint8Clamp: (Unsigned 8 Bit Integer, Clamped)

The abstract operation ToUint8Clamp converts its argument to one of 2⁸ integer values in the range 0 through 255, inclusive. This abstract operation functions as follows:

1. Let number be the result of calling ToNumber on the input argument.
2. ReturnIfAbrupt(number).
3. If number is NaN, return +0.
4. If number ≤ 0, return +0.
5. If number > 255, return 255.
6. Let f be floor(number).
7. If f+0.5 ≤ number, then return f+1.
8. Return f.

7.1.13 ToObject

The abstract operation ToObject converts its argument to a value of type Object according to Table 13:

7.1.14 ToPropertyKey

The abstract operation ToPropertyKey converts its argument to a value that can be used as a property key by performing the following steps:

1. ReturnIfAbrupt(argument).
2. If Type(argument) is Symbol, then
   1. Return argument.
3. Return ToString(argument).

7.1.15 ToLength

The abstract operation ToLength converts its argument to an integer suitable for use as the length of an array-like object. It performs the following steps:

1. Let len be ToInteger(argument).
2. ReturnIfAbrupt(len).
3. If len ≤ +0, then return +0.
4. Return min(len, 2⁵³-1).

7.2.1 CheckObjectCoercible

The abstract operation CheckObjectCoercible throws an error if its argument is a value that cannot be converted to an Object using ToObject. It is defined by Table 14:

7.2.2 IsCallable

The abstract operation IsCallable determines if its argument, which must be an ECMAScript language value or a Completion Record, is a callable function Object according to Table 15:

7.2.3 SameValue(x, y)

The internal comparison abstract operation SameValue(x, y), where x and y are ECMAScript language values, produces true or false. Such a comparison is performed as follows:

1. ReturnIfAbrupt(x).
2. ReturnIfAbrupt(y).
3. If Type(x) is different from Type(y), return false.
4. If Type(x) is Undefined, return true.
5. If Type(x) is Null, return true.
6. If Type(x) is Number, then
   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 the same Number value as y, return true.
   5. Return false.
7. If Type(x) is String, then
   1. If x and y are exactly the same sequence of code units (same length and same code units in corresponding positions) return true; otherwise, return false.
8. If Type(x) is Boolean, then
   1. If x and y are both true or both false, then return true; otherwise, return false.
9. If Type(x) is Symbol, then
   1. If x and y are both the same Symbol value, then return true; otherwise, return false.
10. Return true if x and y are the same Object value. Otherwise, return false.

7.2.4 SameValueZero(x, y)

The internal comparison abstract operation SameValueZero(x, y), where x and y are ECMAScript language values, produces true or false. Such a comparison is performed as follows:

1. ReturnIfAbrupt(x).
2. ReturnIfAbrupt(y).
3. If Type(x) is different from Type(y), return false.
4. If Type(x) is Undefined, return true.
5. If Type(x) is Null, return true.
6. If Type(x) is Number, then
   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 the same Number value as y, return true.
   5. Return false.
7. If Type(x) is String, then
   1. If x and y are exactly the same sequence of code units (same length and same code units in corresponding positions) return true; otherwise, return false.
8. If Type(x) is Boolean, then
   1. If x and y are both true or both false, then return true; otherwise, return false.
9. If Type(x) is Symbol, then
   1. If x and y are both the same Symbol value, then return true; otherwise, return false.
10. Return true if x and y are the same Object value. Otherwise, return false.

7.2.5 IsConstructor

The abstract operation IsConstructor determines if its argument, which must be an ECMAScript language value or a Completion Record, is a function object with a [[Construct]] internal method.

1. ReturnIfAbrupt(argument).
2. If Type(argument) is not Object, return false.
3. If argument has a [[Construct]] internal method, return true.
4. Return false.

7.2.6 IsPropertyKey

The abstract operation IsPropertyKey determines if its argument, which must be an ECMAScript language value or a Completion Record, is a value that may be used as a property key.

1. ReturnIfAbrupt(argument).
2. If Type(argument) is String, return true.
3. If Type(argument) is Symbol, return true.
4. Return false.

7.2.7 IsExtensible (O)

The abstract operation IsExtensible is used to determine whether additional properties can be added to the object that is O. A Boolean value is returned. This abstract operation performs the following steps:

1. Assert: Type(O) is Object.
2. Return the result of calling the [[IsExtensible]] internal method of O.

7.2.8 Abstract Relational Comparison

The comparison x < y, where x and y are values, produces true, false, or undefined (which indicates that at least one operand is NaN). In addition to x and y the algorithm takes a Boolean flag named LeftFirst as a parameter. The flag is used to control the order in which operations with potentially visible side-effects are performed upon x and y. It is necessary because ECMAScript specifies left to right evaluation of expressions. The default value of LeftFirst is true and indicates that the x parameter corresponds to an expression that occurs to the left of the y parameter’s corresponding expression. If LeftFirst is false, the reverse is the case and operations must be performed upon y before x. Such a comparison is performed as follows:

1. ReturnIfAbrupt(x).
2. ReturnIfAbrupt(y).
3. If the LeftFirst flag is true, then
   1. Let px be the result of calling ToPrimitive(x, hint Number).
   2. ReturnIfAbrupt(px).
   3. Let py be the result of calling ToPrimitive(y, hint Number).
   4. ReturnIfAbrupt(py).
4. Else the order of evaluation needs to be reversed to preserve left to right evaluation
   1. Let py be the result of calling ToPrimitive(y, hint Number).
   2. ReturnIfAbrupt(py).
   3. Let px be the result of calling ToPrimitive(x, hint Number).
   4. ReturnIfAbrupt(px).
5. If both px and py are Strings, then
   1. If py is a prefix of px, return false. (A String value p is a prefix of String value q if q can be the result of concatenating p and some other String r. Note that any String is a prefix of itself, because r may be the empty String.)
   2. If px is a prefix of py, return true.
   3. Let k be the smallest nonnegative integer such that the character at position k within px is different from the character at position k within py. (There must be such a k, for neither String is a prefix of the other.)
   4. Let m be the integer that is the code unit value for the character at position k within px.
   5. Let n be the integer that is the code unit value for the character at position k within py.
   6. If m < n, return true. Otherwise, return false.
6. Else,
   1. Let nx be the result of calling ToNumber(px). Because px and py are primitive values evaluation order is not important.
   2. Let ny be the result of calling ToNumber(py).
   3. If nx is NaN, return undefined.
   4. If ny is NaN, return undefined.
   5. If nx and ny are the same Number value, return false.
   6. If nx is +0 and ny is −0, return false.
   7. If nx is −0 and ny is +0, return false.
   8. If nx is +∞, return false.
   9. If ny is +∞, return true.
   10. If ny is −∞, return false.
   11. If nx is −∞, return true.
   12. If the mathematical value of nx is less than the mathematical value of ny —note that these mathematical values are both finite and not both zero—return true. Otherwise, return false.

7.2.9 Abstract Equality Comparison

The comparison x == y, where x and y are values, produces true or false. Such a comparison is performed as follows:

1. If Type(x) is the same as Type(y), then
   1. Return the result of performing Strict Equality Comparison x === y.
2. If x is null and y is undefined, return true.
3. If x is undefined and y is null, return true.
4. If Type(x) is Number and Type(y) is String,
   return the result of the comparison x == ToNumber(y).
5. If Type(x) is String and Type(y) is Number,
   return the result of the comparison ToNumber(x) == y.
6. If Type(x) is Boolean, return the result of the comparison ToNumber(x) == y.
7. If Type(y) is Boolean, return the result of the comparison x == ToNumber(y).
8. If Type(x) is either String or Number and Type(y) is Object,
   return the result of the comparison x == ToPrimitive(y).
9. If Type(x) is Object and Type(y) is either String or Number,
   return the result of the comparison ToPrimitive(x) == y.
10. Return false.

7.2.10 Strict Equality Comparison

The comparison x === y, where x and y are values, produces true or false. Such a comparison is performed as follows:

1. If Type(x) is different from Type(y), return false.
2. If Type(x) is Undefined, return true.
3. If Type(x) is Null, return true.
4. If Type(x) is Number, then
   1. If x is NaN, return false.
   2. If y is NaN, return false.
   3. If x is the same Number value as 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.
5. If Type(x) is String, then
   1. If x and y are exactly the same sequence of characters (same length and same characters in corresponding positions), return true.
   2. Else, return false.
6. If Type(x) is Boolean, then
   1. If x and y are both true or both false, return true.
   2. Else, return false.
7. If x and y are the same Symbol value, return true.
8. If x and y are the same Object value, return true.
9. Return false.

7.3.1 Get (O, P)

The abstract operation Get is used to retrieve the value of a specific property of an object. The operation is called with arguments O and P where O is the object and P is the property key. This abstract operation performs the following steps:

1. Assert: Type(O) is Object.
2. Assert: IsPropertyKey(P) is true.
3. Return the result of calling the [[Get]] internal method of O passing P and O as the arguments.

7.3.2 Put (O, P, V, Throw)

The abstract operation Put is used to set the value of a specific property of an object. The operation is called with arguments O, P, V, and Throw where O is the object, P is the property key, V is the new value for the property and Throw is a Boolean flag. This abstract operation performs the following steps:

1. Assert: Type(O) is Object.
2. Assert: IsPropertyKey(P) is true.
3. Assert: Type(Throw) is Boolean.
4. Let success be the result of calling the [[Set]] internal method of O passing P, V, and O as the arguments.
5. ReturnIfAbrupt(success).
6. If success is false and Throw is true, then throw a TypeError exception.
7. Return success.

7.3.3 CreateDataProperty (O, P, V)

The abstract operation CreateDataProperty is used to create a new own property of an object. The operation is called with arguments O, P, and V where O is the object, P is the property key, and V is the value for the property. This abstract operation performs the following steps:

1. Assert: Type(O) is Object.
2. Assert: IsPropertyKey(P) is true.
3. Let newDesc be the PropertyDescriptor{[[Value]]: V, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}.
4. Return the result of calling the [[DefineOwnProperty]] internal method of O passing P and newDesc as arguments.

7.3.4 CreateDataPropertyOrThrow (O, P, V)

The abstract operation CreateDataPropertyOrThrow is used to create a new own property of an object. It throws a TypeError exception if the requested property update cannot be performed. The operation is called with arguments O, P, and V where O is the object, P is the property key, and V is the value for the property. This abstract operation performs the following steps:

1. Assert: Type(O) is Object.
2. Assert: IsPropertyKey(P) is true.
3. Let success be the result of CreateDataProperty(O, P, V).
4. ReturnIfAbrupt(success).
5. If success is false, then throw a TypeError exception.
6. Return success.

7.3.5 DefinePropertyOrThrow (O, P, desc)

The abstract operation DefinePropertyOrThrow is used to call the [[DefineOwnProperlty]] internal method of an object in a manner that will throw a TypeError exception if the requested property update cannot be performed. The operation is called with arguments O, P, and desc where O is the object, P is the property key, and desc is the Property Descriptor for the property. This abstract operation perform, the following steps:

1. Assert: Type(O) is Object.
2. Assert: IsPropertyKey(P) is true.
3. Let success be the result of calling the [[DefineOwnProperty]] internal method of O passing P and desc as arguments.
4. ReturnIfAbrupt(success).
5. If success is false, then throw a TypeError exception.
6. Return success.

7.3.6 DeletePropertyOrThrow (O, P)

The abstract operation DeletePropertyOrThrow is used to remove a specific own property of an object. It throws an exception if the property is not configurable. The operation is called with arguments O and P where O is the object and P is the property key. This abstract operation performs the following steps:

1. Assert: Type(O) is Object.
2. Assert: IsPropertyKey(P) is true.
3. Let success be the result of calling the [[Delete]] internal method of O passing P as the argument.
4. ReturnIfAbrupt(success).
5. If success is false, then throw a TypeError exception.
6. Return success.