Objects

Even though ECMAScript includes syntax for class definitions, ECMAScript objects are not fundamentally class-based 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 initializes 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 most 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.

Although ECMAScript objects are not inherently class-based, it is often convenient to define class-like abstractions based upon a common pattern of constructor functions, prototype objects, and methods. The ECMAScript built-in objects themselves follow such a class-like pattern. Beginning with ECMAScript 2015, the ECMAScript language includes syntactic class definitions that permit programmers to concisely define objects that conform to the same class-like abstraction pattern used by the built-in objects.

The Strict Variant of ECMAScript

The ECMAScript Language recognizes 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 source text units as described in . Because strict mode is selected at the level of a syntactic source text unit, strict mode only imposes restrictions that have local effect within such a source text unit. Strict mode does not restrict or modify any aspect of the ECMAScript semantics that must operate consistently across multiple source text units. A complete ECMAScript program may be composed of both strict mode and non-strict mode ECMAScript source text units. In this case, strict mode only applies when actually executing code that is defined within a strict mode source text unit.

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

implementation-approximated

an implementation-approximated facility is defined in whole or in part by an external source but has a recommended, ideal behaviour in this specification

implementation-defined

an implementation-defined facility is defined in whole or in part by an external source to this specification

host-defined

same as implementation-defined

type

set of data values as defined in clause

primitive value

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

object

member of the type Object

constructor

function object that creates and initializes objects

prototype

object that provides shared properties for other objects

ordinary object

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

exotic object

object that does not have the default behaviour for one or more of the essential internal methods

standard object

object whose semantics are defined by this specification

built-in object

object specified and supplied by an ECMAScript implementation

undefined value

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

Undefined type

type whose sole value is the *undefined* value

null value

primitive value that represents the intentional absence of any object value

Null type

type whose sole value is the *null* value

Boolean value

member of the Boolean type

Boolean type

type consisting of the primitive values *true* and *false*

Boolean object

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

String value

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

String type

set of all possible String values

String object

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

Number value

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

Number type

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

Number object

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

Infinity

Number value that is the positive infinite Number value

NaN

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

BigInt value

primitive value corresponding to an arbitrary-precision integer value

BigInt type

set of all possible BigInt values

BigInt object

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

Symbol value

primitive value that represents a unique, non-String Object property key

Symbol type

set of all possible Symbol values

Symbol object

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

function

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

built-in function

built-in object that is a function

built-in constructor

built-in function that is a constructor

property

part of an object that associates a key (either a String value or a Symbol value) and a value

method

function that is the value of a property

built-in method

method that is a built-in function

attribute

internal value that defines some characteristic of a property

own property

property that is directly contained by its object

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

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.

The Lexical and RegExp Grammars

A lexical grammar for ECMAScript is given in clause . This grammar has as its terminal symbols Unicode code points that conform to the rules for |SourceCharacter| defined in . It defines a set of productions, starting from the goal symbol |InputElementDiv|, |InputElementTemplateTail|, |InputElementRegExp|, |InputElementRegExpOrTemplateTail|, or |InputElementHashbangOrRegExp|, that describe how sequences of such code points 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 (). 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 . This grammar also has as its terminal symbols the code points as defined by |SourceCharacter|. It defines a set of productions, starting from the goal symbol |Pattern|, that describe how sequences of code points 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.

The Numeric String Grammar

A numeric string grammar appears in . It has as its terminal symbols |SourceCharacter|, and is used for translating Strings into numeric values starting from the goal symbol |StringNumericLiteral| (which is similar to but distinct from the lexical grammar for numeric literals).

Productions of the numeric string grammar are distinguished by having three colons “:::” as punctuation, and are never used for parsing source text.

The Syntactic Grammar

The syntactic grammar for ECMAScript is given in clauses through . This grammar has ECMAScript tokens defined by the lexical grammar as its terminal symbols (). It defines a set of productions, starting from two alternative goal symbols |Script| and |Module|, that describe how sequences of tokens form syntactically correct independent components of ECMAScript programs.

When a stream of code points is to be parsed as an ECMAScript |Script| or |Module|, 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 input stream 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| or |Module|), with no tokens left over.

When a parse is successful, it constructs a parse tree, a rooted tree structure in which each node is a Parse Node. Each Parse Node is an instance of a symbol in the grammar; it represents a span of the source text that can be derived from that symbol. The root node of the parse tree, representing the whole of the source text, is an instance of the parse's goal symbol. When a Parse Node is an instance of a nonterminal, it is also an instance of some production that has that nonterminal as its left-hand side. Moreover, it has zero or more children, one for each symbol on the production's right-hand side: each child is a Parse Node that is an instance of the corresponding symbol.

New Parse Nodes are instantiated for each invocation of the parser and never reused between parses even of identical source text. Parse Nodes are considered the same Parse Node if and only if they represent the same span of source text, are instances of the same grammar symbol, and resulted from the same parser invocation.

          let str = "1 + 1;";
          eval(str);
          eval(str);
        

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

The syntactic grammar as presented in clauses through is not a complete account of which token sequences are accepted as a correct ECMAScript |Script| or |Module|. 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 line terminator character appears in certain “awkward” places.

In certain cases, in order to avoid ambiguities, the syntactic grammar uses generalized productions that permit token sequences that do not form a valid ECMAScript |Script| or |Module|. For example, this technique is used for object literals and object destructuring patterns. In such cases a more restrictive supplemental grammar is provided that further restricts the acceptable token sequences. Typically, an early error rule will then state that, in certain contexts, "_P_ must cover an _N_", where _P_ is a Parse Node (an instance of the generalized production) and _N_ is a nonterminal from the supplemental grammar. This means:

1. The sequence of tokens originally matched by _P_ is parsed again using _N_ as the goal symbol. If _N_ takes grammatical parameters, then they are set to the same values used when _P_ was originally parsed.
2. If the sequence of tokens can be parsed as a single instance of _N_, with no tokens left over, then:
   1. We refer to that instance of _N_ (a Parse Node, unique for a given _P_) as "the _N_ that is covered by _P_".
   2. All Early Error rules for _N_ and its derived productions also apply to the _N_ that is covered by _P_.
3. Otherwise (if the parse fails), it is an early Syntax Error.

Grammar Notation

Abstract Operations

In order to facilitate their use in multiple parts of this specification, some algorithms, called abstract operations, are named and written in parameterized functional form so that they may be referenced by name from within other algorithms. Abstract operations are typically referenced using a functional application style such as OperationName(_arg1_, _arg2_). Some abstract operations are treated as polymorphically dispatched methods of class-like specification abstractions. Such method-like abstract operations are typically referenced using a method application style such as _someValue_.OperationName(_arg1_, _arg2_).

Syntax-Directed Operations

A syntax-directed operation is a named operation whose definition consists of algorithms, each of which is associated with one or more productions from one of the ECMAScript grammars. A production that has multiple alternative definitions will typically have a distinct algorithm for each alternative. When an algorithm is associated with a grammar production, it may reference the terminal and nonterminal symbols of the production alternative as if they were parameters of the algorithm. When used in this manner, nonterminal symbols refer to the actual alternative definition that is matched when parsing the source text. The source text matched by a grammar production or Parse Node derived from it is the portion of the source text that starts at the beginning of the first terminal that participated in the match and ends at the end of the last terminal that participated in the match.

When an algorithm is associated with a production alternative, the alternative is typically shown without any “[ ]” grammar annotations. Such annotations should only affect the syntactic recognition of the alternative and have no effect on the associated semantics for the alternative.

Syntax-directed operations are invoked with a parse node and, optionally, other parameters by using the conventions on steps , , and in the following algorithm:

Unless explicitly specified otherwise, all chain productions have an implicit definition for every operation that might be applied to that production's left-hand side nonterminal. The implicit definition simply reapplies the same operation with the same parameters, if any, to the chain production's sole right-hand side nonterminal and then returns the result. For example, assume that some algorithm has a step of the form: “Return Evaluation of |Block|” and that there is a production:

but the Evaluation operation does not associate an algorithm with that production. In that case, the Evaluation operation implicitly includes an association of the form:

Runtime Semantics: Evaluation

Runtime Semantics

Algorithms which specify semantics that must be called at runtime are called runtime semantics. Runtime semantics are defined by abstract operations or syntax-directed operations.

Static Semantics

Context-free grammars are not sufficiently powerful to express all the rules that define whether a stream of input elements form a valid ECMAScript |Script| or |Module| that may be evaluated. In some situations additional rules are needed that may be expressed using either ECMAScript algorithm conventions or prose requirements. Such rules are always associated with a production of a grammar and are called the static semantics of the production.

Static Semantic Rules have names and typically are defined using an algorithm. Named Static Semantic Rules are associated with grammar productions and a production that has multiple alternative definitions will typically have for each alternative a distinct algorithm for each applicable named static semantic rule.

A special kind of static semantic rule is an Early Error Rule. Early error rules define early error conditions (see clause ) that are associated with specific grammar productions. Evaluation of most early error rules are not explicitly invoked within the algorithms of this specification. A conforming implementation must, prior to the first evaluation of a |Script| or |Module|, validate all of the early error rules of the productions used to parse that |Script| or |Module|. If any of the early error rules are violated the |Script| or |Module| is invalid and cannot be evaluated.

Mathematical Operations

This specification makes reference to these kinds of numeric values:

• Mathematical values: Arbitrary real numbers, used as the default numeric type.
• Extended mathematical values: Mathematical values together with +∞ and -∞.
• Numbers: IEEE 754-2019 binary64 (double-precision floating point) values.
• BigInts: ECMAScript language values representing arbitrary integers in a one-to-one correspondence.

In the language of this specification, numerical values are distinguished among different numeric kinds using subscript suffixes. The subscript _𝔽 refers to Numbers, and the subscript _ℤ refers to BigInts. Numeric values without a subscript suffix refer to mathematical values. This specification denotes most numeric values in base 10; it also uses numeric values of the form 0x followed by digits 0-9 or A-F as base-16 values.

In general, when this specification refers to a numerical value, such as in the phrase, "the length of _y_" or "the integer represented by the four hexadecimal digits ...", without explicitly specifying a numeric kind, the phrase refers to a mathematical value. Phrases which refer to a Number or a BigInt value are explicitly annotated as such; for example, "the Number value for the number of code points in …" or "the BigInt value for …".

When the term integer is used in this specification, it refers to a mathematical value which is in the set of integers, unless otherwise stated. When the term integral Number is used in this specification, it refers to a Number value whose mathematical value is in the set of integers.

Numeric operators such as +, ×, =, and ≥ refer to those operations as determined by the type of the operands. When applied to mathematical values, the operators refer to the usual mathematical operations. When applied to extended mathematical values, the operators refer to the usual mathematical operations over the extended real numbers; indeterminate forms are not defined and their use in this specification should be considered an editorial error. When applied to Numbers, the operators refer to the relevant operations within IEEE 754-2019. When applied to BigInts, the operators refer to the usual mathematical operations applied to the mathematical value of the BigInt. Numeric operators applied to mixed-type operands (such as a Number and a mathematical value) are not defined and should be considered an editorial error in this specification.

Conversions between mathematical values and Numbers or BigInts are always explicit in this document. A conversion from a mathematical value or extended mathematical value _x_ to a Number is denoted as "the Number value for _x_" or 𝔽(_x_), and is defined in . A conversion from an integer _x_ to a BigInt is denoted as "the BigInt value for _x_" or ℤ(_x_). A conversion from a Number or BigInt _x_ to a mathematical value is denoted as "the mathematical value of _x_", or ℝ(_x_). The mathematical value of *+0*_𝔽 and *-0*_𝔽 is the mathematical value 0. The mathematical value of non-finite values is not defined. The extended mathematical value of _x_ is the mathematical value of _x_ for finite values, and is +∞ and -∞ for *+∞*_𝔽 and *-∞*_𝔽 respectively; it is not defined for *NaN*.

The mathematical function abs(_x_) produces the absolute value of _x_, which is -_x_ if _x_ < 0 and otherwise is _x_ itself.

The mathematical function min(_x1_, _x2_, … , _xN_) produces the mathematically smallest of _x1_ through _xN_. The mathematical function max(_x1_, _x2_, ..., _xN_) produces the mathematically largest of _x1_ through _xN_. The domain and range of these mathematical functions are the extended mathematical values.

The notation “_x_ modulo _y_” (_y_ must be finite and non-zero) computes a value _k_ of the same sign as _y_ (or zero) such that abs(_k_) < abs(_y_) and _x_ - _k_ = _q_ × _y_ for some integer _q_.

The phrase "the result of clamping _x_ between _lower_ and _upper_" (where _x_ is an extended mathematical value and _lower_ and _upper_ are mathematical values such that _lower_ ≤ _upper_) produces _lower_ if _x_ < _lower_, produces _upper_ if _x_ > _upper_, and otherwise produces _x_.

The mathematical function floor(_x_) produces the largest integer (closest to +∞) that is not larger than _x_.

The mathematical function truncate(_x_) removes the fractional part of _x_ by rounding towards zero, producing -floor(-_x_) if _x_ < 0 and otherwise producing floor(_x_).

Mathematical functions min, max, abs, floor, and truncate are not defined for Numbers and BigInts, and any usage of those methods that have non-mathematical value arguments would be an editorial error in this specification.

An interval from lower bound _a_ to upper bound _b_ is a possibly-infinite, possibly-empty set of numeric values of the same numeric type. Each bound will be described as either inclusive or exclusive, but not both. There are four kinds of intervals, as follows:

• An interval from _a_ (inclusive) to _b_ (inclusive), also called an inclusive interval from _a_ to _b_, includes all values _x_ of the same numeric type such that _a_ ≤ _x_ ≤ _b_, and no others.
• An interval from _a_ (inclusive) to _b_ (exclusive) includes all values _x_ of the same numeric type such that _a_ ≤ _x_ < _b_, and no others.
• An interval from _a_ (exclusive) to _b_ (inclusive) includes all values _x_ of the same numeric type such that _a_ < _x_ ≤ _b_, and no others.
• An interval from _a_ (exclusive) to _b_ (exclusive) includes all values _x_ of the same numeric type such that _a_ < _x_ < _b_, and no others.

For example, the interval from 1 (inclusive) to 2 (exclusive) consists of all mathematical values between 1 and 2, including 1 and not including 2. For the purpose of defining intervals, *-0*_𝔽 < *+0*_𝔽, so, for example, an inclusive interval with a lower bound of *+0*_𝔽 includes *+0*_𝔽 but not *-0*_𝔽. *NaN* is never included in an interval.

Value Notation

In this specification, ECMAScript language values are displayed in *bold*. Examples include *null*, *true*, or *"hello"*. These are distinguished from ECMAScript source text such as `Function.prototype.apply` or `let n = 42;`.

Identity

In this specification, both specification values and ECMAScript language values are compared for equality. When comparing for equality, values fall into one of two categories. Values without identity are equal to other values without identity if all of their innate characteristics are the same — characteristics such as the magnitude of an integer or the length of a sequence. Values without identity may be manifest without prior reference by fully describing their characteristics. In contrast, each value with identity is unique and therefore only equal to itself. Values with identity are like values without identity but with an additional unguessable, unchangeable, universally-unique characteristic called identity. References to existing values with identity cannot be manifest simply by describing them, as the identity itself is indescribable; instead, references to these values must be explicitly passed from one place to another. Some values with identity are mutable and therefore can have their characteristics (except their identity) changed in-place, causing all holders of the value to observe the new characteristics. A value without identity is never equal to a value with identity.

From the perspective of this specification, the word “is” is used to compare two values for equality, as in “If _bool_ is *true*, then ...”, and the word “contains” is used to search for a value inside lists using equality comparisons, as in "If _list_ contains a Record _r_ such that _r_.[[Foo]] is *true*, then ...". The specification identity of values determines the result of these comparisons and is axiomatic in this specification.

From the perspective of the ECMAScript language, language values are compared for equality using the SameValue abstract operation and the abstract operations it transitively calls. The algorithms of these comparison abstract operations determine language identity of ECMAScript language values.

For specification values, examples of values without specification identity include, but are not limited to: mathematical values and extended mathematical values; ECMAScript source text, surrogate pairs, Directive Prologues, etc; UTF-16 code units; Unicode code points; enums; abstract operations, including syntax-directed operations, host hooks, etc; and ordered pairs. Examples of specification values with specification identity include, but are not limited to: any kind of Records, including Property Descriptors, PrivateElements, etc; Parse Nodes; Lists; Sets and Relations; Abstract Closures; Data Blocks; Private Names; execution contexts and execution context stacks; agent signifiers; and WaiterList Records.

Specification identity agrees with language identity for all ECMAScript language values except Symbol values produced by Symbol.for. The ECMAScript language values without specification identity and without language identity are *undefined*, *null*, Booleans, Strings, Numbers, and BigInts. The ECMAScript language values with specification identity and language identity are Symbols not produced by Symbol.for and Objects. Symbol values produced by Symbol.for have specification identity, but not language identity.

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*.

The Null Type

The Null type has exactly one value, called *null*.

The Boolean Type

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

The String Type

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

ECMAScript operations that do not interpret String contents apply no further semantics. Operations that do interpret String values treat each element as a single UTF-16 code unit. However, ECMAScript does not restrict the value of or relationships between these code units, so operations that further interpret String contents as sequences of Unicode code points encoded in UTF-16 must account for ill-formed subsequences. Such operations apply special treatment to every code unit with a numeric value in the inclusive interval from 0xD800 to 0xDBFF (defined by the Unicode Standard as a leading surrogate, or more formally as a high-surrogate code unit) and every code unit with a numeric value in the inclusive interval from 0xDC00 to 0xDFFF (defined as a trailing surrogate, or more formally as a low-surrogate code unit) using the following rules:

• A code unit that is not a leading surrogate and not a trailing surrogate is interpreted as a code point with the same value.
• A sequence of two code units, where the first code unit _c1_ is a leading surrogate and the second code unit _c2_ a trailing surrogate, is a surrogate pair and is interpreted as a code point with the value (_c1_ - 0xD800) × 0x400 + (_c2_ - 0xDC00) + 0x10000. (See )
• A code unit that is a leading surrogate or trailing surrogate, but is not part of a surrogate pair, is interpreted as a code point with the same value.

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

In this specification, the phrase "the string-concatenation of _A_, _B_, ..." (where each argument is a String value, a code unit, or a sequence of code units) denotes the String value whose sequence of code units is the concatenation of the code units (in order) of each of the arguments (in order).

The phrase "the substring of _S_ from _inclusiveStart_ to _exclusiveEnd_" (where _S_ is a String value or a sequence of code units and _inclusiveStart_ and _exclusiveEnd_ are integers) denotes the String value consisting of the consecutive code units of _S_ beginning at index _inclusiveStart_ and ending immediately before index _exclusiveEnd_ (which is the empty String when _inclusiveStart_ = _exclusiveEnd_). If the "to" suffix is omitted, the length of _S_ is used as the value of _exclusiveEnd_.

The phrase "the ASCII word characters" denotes the following String value, which consists solely of every letter and number in the Unicode Basic Latin block along with U+005F (LOW LINE):
*"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"*.
For historical reasons, it has significance to various algorithms.

The Symbol Type

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

Each possible Symbol value is unique and immutable.

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

Numeric Types

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

Because the numeric types are in general not convertible without loss of precision or truncation, the ECMAScript language provides no implicit conversion among these types. Programmers must explicitly call `Number` and `BigInt` functions to convert among types when calling a function which requires another type.

The Object Type

Each instance of the Object type, also referred to simply as “an Object”, represents a collection of properties. Each property is either a data property, or an accessor property:

• A data property associates a key value with an ECMAScript language value and a set of Boolean attributes.
• An accessor property associates a key value with one or two accessor functions, and a set of Boolean attributes. The accessor functions are used to store or retrieve an ECMAScript language value that is associated with the property.

The properties of an object are uniquely identified using property keys. A property key is either a String or a Symbol. All Strings and Symbols, including the empty String, are valid as property keys. A property name is a property key that is a String.

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

Property keys are used to access properties and their values. There are two kinds of access for properties: get and set, corresponding to value retrieval and assignment, respectively. The properties accessible via get and set access includes both own properties that are a direct part of an object and inherited properties which are provided by another associated object via a property inheritance relationship. Inherited properties may be either own or inherited properties of the associated object. Each own property of an object must each have a key value that is distinct from the key values of the other own properties of that object.

All objects are logically collections of properties, but there are multiple forms of objects that differ in their semantics for accessing and manipulating their properties. Please see for definitions of the multiple forms of objects.

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

The Enum Specification Type

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

The List and Record Specification Types

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

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

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

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

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

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

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

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

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

The Set and Relation Specification Types

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

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

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

• For all _a_, _b_, and _c_ in _R_'s domain:

  • It is not the case that _a_ _R_ _a_, and
  • If _a_ _R_ _b_ and _b_ _R_ _c_, then _a_ _R_ _c_.

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

• For all _a_, _b_, and _c_ in _R_'s domain:

  • _a_ is _b_ or _a_ _R_ _b_ or _b_ _R_ _a_, and
  • It is not the case that _a_ _R_ _a_, and
  • If _a_ _R_ _b_ and _b_ _R_ _c_, then _a_ _R_ _c_.

The Completion Record Specification Type

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

Completion Records have the fields defined in .

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

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

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

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

The Reference Record Specification Type

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

A Reference Record is a resolved name or property binding; its fields are defined by .

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

The Property Descriptor Specification Type

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

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

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

The Environment Record Specification Type

The Environment Record type is used to explain the behaviour of name resolution in nested functions and blocks. This type and the operations upon it are defined in .

The Abstract Closure Specification Type

The Abstract Closure specification type is used to refer to algorithm steps together with a collection of values. Abstract Closures are meta-values and are invoked using function application style such as _closure_(_arg1_, _arg2_). Like abstract operations, invocations perform the algorithm steps described by the Abstract Closure.

In algorithm steps that create an Abstract Closure, values are captured with the verb "capture" followed by a list of aliases. When an Abstract Closure is created, it captures the value that is associated with each alias at that time. In steps that specify the algorithm to be performed when an Abstract Closure is called, each captured value is referred to by the alias that was used to capture the value.

If an Abstract Closure returns a Completion Record, that Completion Record must be either a normal completion or a throw completion.

Abstract Closures are created inline as part of other algorithms, shown in the following example.

Data Blocks

The Data Block specification type is used to describe a distinct and mutable sequence of byte-sized (8 bit) numeric values. A byte value is an integer in the inclusive interval from 0 to 255. A Data Block value is created with a fixed number of bytes that each have the initial value 0.

For notational convenience within this specification, an array-like syntax can be used to access the individual bytes of a Data Block value. This notation presents a Data Block value as a 0-origined integer-indexed sequence of bytes. For example, if _db_ is a 5 byte Data Block value then _db_[2] can be used to access its 3^rd byte.

A data block that resides in memory that can be referenced from multiple agents concurrently is designated a Shared Data Block. A Shared Data Block has an identity (for the purposes of equality testing Shared Data Block values) that is address-free: it is tied not to the virtual addresses the block is mapped to in any process, but to the set of locations in memory that the block represents. Two data blocks are equal only if the sets of the locations they contain are equal; otherwise, they are not equal and the intersection of the sets of locations they contain is empty. Finally, Shared Data Blocks can be distinguished from Data Blocks.

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

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

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

The PrivateElement Specification Type

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

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

The ClassFieldDefinition Record Specification Type

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

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

Private Names

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

The ClassStaticBlockDefinition Record Specification Type

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

ClassStaticBlockDefinition Records have the fields listed in .

ToPrimitive ( _input_: an ECMAScript language value, optional _preferredType_: ~string~ or ~number~, ): either a normal completion containing an ECMAScript language value or a throw completion

description

It 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.

ToBoolean ( _argument_: an ECMAScript language value, ): a Boolean

description

It converts _argument_ to a value of type Boolean.

ToNumeric ( _value_: an ECMAScript language value, ): either a normal completion containing either a Number or a BigInt, or a throw completion

description

It returns _value_ converted to a Number or a BigInt.

ToNumber ( _argument_: an ECMAScript language value, ): either a normal completion containing a Number or a throw completion

description

It converts _argument_ to a value of type Number.

ToIntegerOrInfinity ( _argument_: an ECMAScript language value, ): either a normal completion containing either an integer, +∞, or -∞, or a throw completion

description

It converts _argument_ to an integer representing its Number value with fractional part truncated, or to +∞ or -∞ when that Number value is infinite.

ToInt32 ( _argument_: an ECMAScript language value, ): either a normal completion containing an integral Number or a throw completion

description

It converts _argument_ to one of 2³² integral Number values in the inclusive interval from 𝔽(-2³¹) to 𝔽(2³¹ - 1).

ToUint32 ( _argument_: an ECMAScript language value, ): either a normal completion containing an integral Number or a throw completion

description

It converts _argument_ to one of 2³² integral Number values in the inclusive interval from *+0*_𝔽 to 𝔽(2³² - 1).

ToInt16 ( _argument_: an ECMAScript language value, ): either a normal completion containing an integral Number or a throw completion

description

It converts _argument_ to one of 2¹⁶ integral Number values in the inclusive interval from 𝔽(-2¹⁵) to 𝔽(2¹⁵ - 1).

ToUint16 ( _argument_: an ECMAScript language value, ): either a normal completion containing an integral Number or a throw completion

description

It converts _argument_ to one of 2¹⁶ integral Number values in the inclusive interval from *+0*_𝔽 to 𝔽(2¹⁶ - 1).

ToInt8 ( _argument_: an ECMAScript language value, ): either a normal completion containing an integral Number or a throw completion

description

It converts _argument_ to one of 2⁸ integral Number values in the inclusive interval from *-128*_𝔽 to *127*_𝔽.

ToUint8 ( _argument_: an ECMAScript language value, ): either a normal completion containing an integral Number or a throw completion

description

It converts _argument_ to one of 2⁸ integral Number values in the inclusive interval from *+0*_𝔽 to *255*_𝔽.

ToUint8Clamp ( _argument_: an ECMAScript language value, ): either a normal completion containing an integral Number or a throw completion

description

It clamps and rounds _argument_ to one of 2⁸ integral Number values in the inclusive interval from *+0*_𝔽 to *255*_𝔽.

ToBigInt ( _argument_: an ECMAScript language value, ): either a normal completion containing a BigInt or a throw completion

description

It converts _argument_ to a BigInt value, or throws if an implicit conversion from Number would be required.

StringToBigInt ( _str_: a String, ): a BigInt or *undefined*

ToBigInt64 ( _argument_: an ECMAScript language value, ): either a normal completion containing a BigInt or a throw completion

description

It converts _argument_ to one of 2⁶⁴ BigInt values in the inclusive interval from ℤ(-2⁶³) to ℤ(2⁶³ - 1).

ToBigUint64 ( _argument_: an ECMAScript language value, ): either a normal completion containing a BigInt or a throw completion

description

It converts _argument_ to one of 2⁶⁴ BigInt values in the inclusive interval from *0*_ℤ to ℤ(2⁶⁴ - 1).

ToString ( _argument_: an ECMAScript language value, ): either a normal completion containing a String or a throw completion

description

It converts _argument_ to a value of type String.

ToObject ( _argument_: an ECMAScript language value, ): either a normal completion containing an Object or a throw completion

description

It converts _argument_ to a value of type Object according to :

ToPropertyKey ( _argument_: an ECMAScript language value, ): either a normal completion containing a property key or a throw completion

description

It converts _argument_ to a value that can be used as a property key.

ToLength ( _argument_: an ECMAScript language value, ): either a normal completion containing an integral Number or a throw completion

description

It clamps and truncates _argument_ to an integral Number suitable for use as the length of an array-like object.

CanonicalNumericIndexString ( _argument_: a String, ): a Number or *undefined*

description

If _argument_ is either *"-0"* or exactly matches the result of ToString(_n_) for some Number value _n_, it returns the respective Number value. Otherwise, it returns *undefined*.

A canonical numeric string is any String value for which the CanonicalNumericIndexString abstract operation does not return *undefined*.

ToIndex ( _value_: an ECMAScript language value, ): either a normal completion containing a non-negative integer or a throw completion

description

It converts _value_ to an integer and returns that integer if it is non-negative and corresponds with an integer index. Otherwise, it throws an exception.

RequireObjectCoercible ( _argument_: an ECMAScript language value, ): either a normal completion containing an ECMAScript language value or a throw completion

description

It throws an error if _argument_ is a value that cannot be converted to an Object using ToObject. It is defined by :

IsArray ( _argument_: an ECMAScript language value, ): either a normal completion containing a Boolean or a throw completion

IsCallable ( _argument_: an ECMAScript language value, ): a Boolean

description

It determines if _argument_ is a callable function with a [[Call]] internal method.

IsConstructor ( _argument_: an ECMAScript language value, ): a Boolean

description

It determines if _argument_ is a function object with a [[Construct]] internal method.

IsExtensible ( _O_: an Object, ): either a normal completion containing a Boolean or a throw completion

description

It is used to determine whether additional properties can be added to _O_.

IsIntegralNumber ( _argument_: an ECMAScript language value, ): a Boolean

description

It determines if _argument_ is a finite integral Number value.

IsRegExp ( _argument_: an ECMAScript language value, ): either a normal completion containing a Boolean or a throw completion

Static Semantics: IsStringWellFormedUnicode ( _string_: a String, ): a Boolean

description

It interprets _string_ as a sequence of UTF-16 encoded code points, as described in , and determines whether it is a well formed UTF-16 sequence.

SameValue ( _x_: an ECMAScript language value, _y_: an ECMAScript language value, ): a Boolean

description

It determines whether or not the two arguments are the same value.

SameValueZero ( _x_: an ECMAScript language value, _y_: an ECMAScript language value, ): a Boolean

description

It determines whether or not the two arguments are the same value (ignoring the difference between *+0*_𝔽 and *-0*_𝔽).

SameValueNonNumber ( _x_: an ECMAScript language value, but not a Number, _y_: an ECMAScript language value, but not a Number, ): a Boolean

IsLessThan ( _x_: an ECMAScript language value, _y_: an ECMAScript language value, _LeftFirst_: a Boolean, ): either a normal completion containing either a Boolean or *undefined*, or a throw completion

description

It provides the semantics for the comparison _x_ < _y_, returning *true*, *false*, or *undefined* (which indicates that at least one operand is *NaN*). The _LeftFirst_ 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. If _LeftFirst_ is *true*, 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_.

IsLooselyEqual ( _x_: an ECMAScript language value, _y_: an ECMAScript language value, ): either a normal completion containing a Boolean or a throw completion

description

It provides the semantics for the `==` operator.

IsStrictlyEqual ( _x_: an ECMAScript language value, _y_: an ECMAScript language value, ): a Boolean

description

It provides the semantics for the `===` operator.

MakeBasicObject ( _internalSlotsList_: a List of internal slot names, ): an Object

description

It is the source of all ECMAScript objects that are created algorithmically, including both ordinary objects and exotic objects. It factors out common steps used in creating all objects, and centralizes object creation.

Get ( _O_: an Object, _P_: a property key, ): either a normal completion containing an ECMAScript language value or a throw completion

description

It is used to retrieve the value of a specific property of an object.

GetV ( _V_: an ECMAScript language value, _P_: a property key, ): either a normal completion containing an ECMAScript language value or a throw completion

description

It is used to retrieve the value of a specific property of an ECMAScript language value. If the value is not an object, the property lookup is performed using a wrapper object appropriate for the type of the value.

Set ( _O_: an Object, _P_: a property key, _V_: an ECMAScript language value, _Throw_: a Boolean, ): either a normal completion containing ~unused~ or a throw completion

description

It is used to set the value of a specific property of an object. _V_ is the new value for the property.

CreateDataProperty ( _O_: an Object, _P_: a property key, _V_: an ECMAScript language value, ): either a normal completion containing a Boolean or a throw completion

description

It is used to create a new own property of an object.

CreateDataPropertyOrThrow ( _O_: an Object, _P_: a property key, _V_: an ECMAScript language value, ): either a normal completion containing ~unused~ or a throw completion

description

It is used to create a new own property of an object. It throws a *TypeError* exception if the requested property update cannot be performed.

CreateNonEnumerableDataPropertyOrThrow ( _O_: an Object, _P_: a property key, _V_: an ECMAScript language value, ): ~unused~

description

It is used to create a new non-enumerable own property of an ordinary object.

DefinePropertyOrThrow ( _O_: an Object, _P_: a property key, _desc_: a Property Descriptor, ): either a normal completion containing ~unused~ or a throw completion

description

It is used to call the [[DefineOwnProperty]] internal method of an object in a manner that will throw a *TypeError* exception if the requested property update cannot be performed.

DeletePropertyOrThrow ( _O_: an Object, _P_: a property key, ): either a normal completion containing ~unused~ or a throw completion

description

It is used to remove a specific own property of an object. It throws an exception if the property is not configurable.

GetMethod ( _V_: an ECMAScript language value, _P_: a property key, ): either a normal completion containing either a function object or *undefined*, or a throw completion

description

It is used to get the value of a specific property of an ECMAScript language value when the value of the property is expected to be a function.

HasProperty ( _O_: an Object, _P_: a property key, ): either a normal completion containing a Boolean or a throw completion

description

It is used to determine whether an object has a property with the specified property key. The property may be either own or inherited.

HasOwnProperty ( _O_: an Object, _P_: a property key, ): either a normal completion containing a Boolean or a throw completion

description

It is used to determine whether an object has an own property with the specified property key.

Call ( _F_: an ECMAScript language value, _V_: an ECMAScript language value, optional _argumentsList_: a List of ECMAScript language values, ): either a normal completion containing an ECMAScript language value or a throw completion

description

It is used to call the [[Call]] internal method of a function object. _F_ is the function object, _V_ is an ECMAScript language value that is the *this* value of the [[Call]], and _argumentsList_ is the value passed to the corresponding argument of the internal method. If _argumentsList_ is not present, a new empty List is used as its value.

Construct ( _F_: a constructor, optional _argumentsList_: a List of ECMAScript language values, optional _newTarget_: a constructor, ): either a normal completion containing an Object or a throw completion

description

It is used to call the [[Construct]] internal method of a function object. _argumentsList_ and _newTarget_ are the values to be passed as the corresponding arguments of the internal method. If _argumentsList_ is not present, a new empty List is used as its value. If _newTarget_ is not present, _F_ is used as its value.

SetIntegrityLevel ( _O_: an Object, _level_: ~sealed~ or ~frozen~, ): either a normal completion containing a Boolean or a throw completion

description

It is used to fix the set of own properties of an object.

TestIntegrityLevel ( _O_: an Object, _level_: ~sealed~ or ~frozen~, ): either a normal completion containing a Boolean or a throw completion

description

It is used to determine if the set of own properties of an object are fixed.

CreateArrayFromList ( _elements_: a List of ECMAScript language values, ): an Array

description

It is used to create an Array whose elements are provided by _elements_.

LengthOfArrayLike ( _obj_: an Object, ): either a normal completion containing a non-negative integer or a throw completion

description

It returns the value of the *"length"* property of an array-like object.

An array-like object is any object for which this operation returns a normal completion.

CreateListFromArrayLike ( _obj_: an ECMAScript language value, optional _elementTypes_: a List of names of ECMAScript Language Types, ): either a normal completion containing a List of ECMAScript language values or a throw completion

description

It is used to create a List value whose elements are provided by the indexed properties of _obj_. _elementTypes_ contains the names of ECMAScript Language Types that are allowed for element values of the List that is created.

Invoke ( _V_: an ECMAScript language value, _P_: a property key, optional _argumentsList_: a List of ECMAScript language values, ): either a normal completion containing an ECMAScript language value or a throw completion

description

It is used to call a method property of an ECMAScript language value. _V_ serves as both the lookup point for the property and the *this* value of the call. _argumentsList_ is the list of arguments values passed to the method. If _argumentsList_ is not present, a new empty List is used as its value.

OrdinaryHasInstance ( _C_: an ECMAScript language value, _O_: an ECMAScript language value, ): either a normal completion containing a Boolean or a throw completion

description

It implements the default algorithm for determining if _O_ inherits from the instance object inheritance path provided by _C_.

SpeciesConstructor ( _O_: an Object, _defaultConstructor_: a constructor, ): either a normal completion containing a constructor or a throw completion

description

It is used to retrieve the constructor that should be used to create new objects that are derived from _O_. _defaultConstructor_ is the constructor to use if a constructor @@species property cannot be found starting from _O_.

EnumerableOwnProperties ( _O_: an Object, _kind_: ~key~, ~value~, or ~key+value~, ): either a normal completion containing a List of ECMAScript language values or a throw completion

GetFunctionRealm ( _obj_: a function object, ): either a normal completion containing a Realm Record or a throw completion

CopyDataProperties ( _target_: an Object, _source_: an ECMAScript language value, _excludedItems_: a List of property keys, ): either a normal completion containing ~unused~ or a throw completion

PrivateElementFind ( _O_: an Object, _P_: a Private Name, ): a PrivateElement or ~empty~

PrivateFieldAdd ( _O_: an Object, _P_: a Private Name, _value_: an ECMAScript language value, ): either a normal completion containing ~unused~ or a throw completion

PrivateMethodOrAccessorAdd ( _O_: an Object, _method_: a PrivateElement, ): either a normal completion containing ~unused~ or a throw completion

HostEnsureCanAddPrivateElement ( _O_: an Object, ): either a normal completion containing ~unused~ or a throw completion

description

It allows host environments to prevent the addition of private elements to particular host-defined exotic objects.

An implementation of HostEnsureCanAddPrivateElement must conform to the following requirements:

• If _O_ is not a host-defined exotic object, this abstract operation must return NormalCompletion(~unused~) and perform no other steps.
• Any two calls of this abstract operation with the same argument must return the same kind of Completion Record.

The default implementation of HostEnsureCanAddPrivateElement is to return NormalCompletion(~unused~).

This abstract operation is only invoked by ECMAScript hosts that are web browsers.

PrivateGet ( _O_: an Object, _P_: a Private Name, ): either a normal completion containing an ECMAScript language value or a throw completion

PrivateSet ( _O_: an Object, _P_: a Private Name, _value_: an ECMAScript language value, ): either a normal completion containing ~unused~ or a throw completion

DefineField ( _receiver_: an Object, _fieldRecord_: a ClassFieldDefinition Record, ): either a normal completion containing ~unused~ or a throw completion

InitializeInstanceElements ( _O_: an Object, _constructor_: an ECMAScript function object, ): either a normal completion containing ~unused~ or a throw completion

AddValueToKeyedGroup ( _groups_: a List of Records with fields [[Key]] (an ECMAScript language value) and [[Elements]] (a List of ECMAScript language values), _key_: an ECMAScript language value, _value_: an ECMAScript language value, ): ~unused~

GroupBy ( _items_: an ECMAScript language value, _callbackfn_: an ECMAScript language value, _keyCoercion_: ~property~ or ~zero~, ): either a normal completion containing a List of Records with fields [[Key]] (an ECMAScript language value) and [[Elements]] (a List of ECMAScript language values), or a throw completion

Iterator Records

An Iterator Record is a Record value used to encapsulate an Iterator or AsyncIterator along with the `next` method.

Iterator Records have the fields listed in .

GetIteratorFromMethod ( _obj_: an ECMAScript language value, _method_: a function object, ): either a normal completion containing an Iterator Record or a throw completion

GetIterator ( _obj_: an ECMAScript language value, _kind_: ~sync~ or ~async~, ): either a normal completion containing an Iterator Record or a throw completion

IteratorNext ( _iteratorRecord_: an Iterator Record, optional _value_: an ECMAScript language value, ): either a normal completion containing an Object or a throw completion

IteratorComplete ( _iterResult_: an Object, ): either a normal completion containing a Boolean or a throw completion

IteratorValue ( _iterResult_: an Object, ): either a normal completion containing an ECMAScript language value or a throw completion

IteratorStep ( _iteratorRecord_: an Iterator Record, ): either a normal completion containing either an Object or *false*, or a throw completion

description

It requests the next value from _iteratorRecord_.[[Iterator]] by calling _iteratorRecord_.[[NextMethod]] and returns either *false* indicating that the iterator has reached its end or the IteratorResult object if a next value is available.

IteratorStepValue ( _iteratorRecord_: an Iterator Record, ): either a normal completion containing either an ECMAScript language value or ~done~, or a throw completion

description

It requests the next value from _iteratorRecord_.[[Iterator]] by calling _iteratorRecord_.[[NextMethod]] and returns either ~done~ indicating that the iterator has reached its end or the value from the IteratorResult object if a next value is available.

IteratorClose ( _iteratorRecord_: an Iterator Record, _completion_: a Completion Record, ): a Completion Record

description

It is used to notify an iterator that it should perform any actions it would normally perform when it has reached its completed state.

IfAbruptCloseIterator ( _value_, _iteratorRecord_ )

IfAbruptCloseIterator is a shorthand for a sequence of algorithm steps that use an Iterator Record. An algorithm step of the form:

means the same thing as:

AsyncIteratorClose ( _iteratorRecord_: an Iterator Record, _completion_: a Completion Record, ): a Completion Record

description

It is used to notify an async iterator that it should perform any actions it would normally perform when it has reached its completed state.

CreateIterResultObject ( _value_: an ECMAScript language value, _done_: a Boolean, ): an Object that conforms to the IteratorResult interface

description

It creates an object that conforms to the IteratorResult interface.

CreateListIteratorRecord ( _list_: a List of ECMAScript language values, ): an Iterator Record

description

It creates an Iterator () object record whose `next` method returns the successive elements of _list_.

IteratorToList ( _iteratorRecord_: an Iterator Record, ): either a normal completion containing a List of ECMAScript language values or a throw completion

Static Semantics: BoundNames ( ): a List of Strings

Static Semantics: DeclarationPart ( ): a Parse Node

Static Semantics: IsConstantDeclaration ( ): a Boolean

Static Semantics: LexicallyDeclaredNames ( ): a List of Strings

Static Semantics: LexicallyScopedDeclarations ( ): a List of Parse Nodes

Static Semantics: VarDeclaredNames ( ): a List of Strings

Static Semantics: VarScopedDeclarations ( ): a List of Parse Nodes

Static Semantics: TopLevelLexicallyDeclaredNames ( ): a List of Strings

Static Semantics: TopLevelLexicallyScopedDeclarations ( ): a List of Parse Nodes

Static Semantics: TopLevelVarDeclaredNames ( ): a List of Strings

Static Semantics: TopLevelVarScopedDeclarations ( ): a List of Parse Nodes

Static Semantics: ContainsDuplicateLabels ( _labelSet_: a List of Strings, ): a Boolean

Static Semantics: ContainsUndefinedBreakTarget ( _labelSet_: a List of Strings, ): a Boolean

Static Semantics: ContainsUndefinedContinueTarget ( _iterationSet_: a List of Strings, _labelSet_: a List of Strings, ): a Boolean

Static Semantics: HasName ( ): a Boolean

Static Semantics: IsFunctionDefinition ( ): a Boolean

Static Semantics: IsAnonymousFunctionDefinition ( _expr_: an |AssignmentExpression| Parse Node, an |Initializer| Parse Node, or an |Expression| Parse Node, ): a Boolean

description

It determines if its argument is a function definition that does not bind a name.

Static Semantics: IsIdentifierRef ( ): a Boolean

Runtime Semantics: NamedEvaluation ( _name_: a property key or a Private Name, ): either a normal completion containing a function object or an abrupt completion

Static Semantics: Contains ( _symbol_: a grammar symbol, ): a Boolean

Every grammar production alternative in this specification which is not listed below implicitly has the following default definition of Contains:

Static Semantics: ComputedPropertyContains ( _symbol_: a grammar symbol, ): a Boolean

Runtime Semantics: InstantiateFunctionObject ( _env_: an Environment Record, _privateEnv_: a PrivateEnvironment Record or *null*, ): an ECMAScript function object

Runtime Semantics: BindingInitialization ( _value_: an ECMAScript language value, _environment_: an Environment Record or *undefined*, ): either a normal completion containing ~unused~ or an abrupt completion

Runtime Semantics: IteratorBindingInitialization ( _iteratorRecord_: an Iterator Record, _environment_: an Environment Record or *undefined*, ): either a normal completion containing ~unused~ or an abrupt completion

Static Semantics: AssignmentTargetType ( ): ~simple~ or ~invalid~

Static Semantics: PropName ( ): a String or ~empty~

The Environment Record Type Hierarchy

Environment Records can be thought of as existing in a simple object-oriented hierarchy where Environment Record is an abstract class with three concrete subclasses: Declarative Environment Record, Object Environment Record, and Global Environment Record. Function Environment Records and Module Environment Records are subclasses of Declarative Environment Record.

• Environment Record (abstract)

  • A Declarative Environment Record is used to define the effect of ECMAScript language syntactic elements such as |FunctionDeclaration|s, |VariableDeclaration|s, and |Catch| clauses that directly associate identifier bindings with ECMAScript language values.

    • A Function Environment Record corresponds to the invocation of an ECMAScript function object, and contains bindings for the top-level declarations within that function. It may establish a new `this` binding. It also captures the state necessary to support `super` method invocations.

    • A Module Environment Record contains the bindings for the top-level declarations of a |Module|. It also contains the bindings that are explicitly imported by the |Module|. Its [[OuterEnv]] is a Global Environment Record.

  • An Object Environment Record is used to define the effect of ECMAScript elements such as |WithStatement| that associate identifier bindings with the properties of some object.

  • A Global Environment Record is used for |Script| global declarations. It does not have an outer environment; its [[OuterEnv]] is *null*. It may be prepopulated with identifier bindings and it includes an associated global object whose properties provide some of the global environment's identifier bindings. As ECMAScript code is executed, additional properties may be added to the global object and the initial properties may be modified.

The Environment Record abstract class includes the abstract specification methods defined in . These abstract methods have distinct concrete algorithms for each of the concrete subclasses.

function f() { eval("var x; x = (delete x, 0);"); }

Environment Record Operations

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

PrivateEnvironment Record Operations

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

CreateRealm ( ): a Realm Record

CreateIntrinsics ( _realmRec_: a Realm Record, ): ~unused~

SetRealmGlobalObject ( _realmRec_: a Realm Record, _globalObj_: an Object or *undefined*, _thisValue_: an Object or *undefined*, ): ~unused~

SetDefaultGlobalBindings ( _realmRec_: a Realm Record, ): either a normal completion containing an Object or a throw completion

GetActiveScriptOrModule ( ): a Script Record, a Module Record, or *null*

description

It is used to determine the running script or module, based on the running execution context.

ResolveBinding ( _name_: a String, optional _env_: an Environment Record or *undefined*, ): either a normal completion containing a Reference Record or a throw completion

description

It is used to determine the binding of _name_. _env_ can be used to explicitly provide the Environment Record that is to be searched for the binding.

GetThisEnvironment ( ): an Environment Record

description

It finds the Environment Record that currently supplies the binding of the keyword `this`.

ResolveThisBinding ( ): either a normal completion containing an ECMAScript language value or a throw completion

description

It determines the binding of the keyword `this` using the LexicalEnvironment of the running execution context.

GetNewTarget ( ): an Object or *undefined*

description

It determines the NewTarget value using the LexicalEnvironment of the running execution context.

GetGlobalObject ( ): an Object

description

It returns the global object used by the currently running execution context.

JobCallback Records

A JobCallback Record is a Record value used to store a function object and a host-defined value. Function objects that are invoked via a Job enqueued by the host may have additional host-defined context. To propagate the state, Job Abstract Closures should not capture and call function objects directly. Instead, use HostMakeJobCallback and HostCallJobCallback.

JobCallback Records have the fields listed in .

HostMakeJobCallback ( _callback_: a function object, ): a JobCallback Record

An implementation of HostMakeJobCallback must conform to the following requirements:

• It must return a JobCallback Record whose [[Callback]] field is _callback_.

The default implementation of HostMakeJobCallback performs the following steps when called:

ECMAScript hosts that are not web browsers must use the default implementation of HostMakeJobCallback.

HostCallJobCallback ( _jobCallback_: a JobCallback Record, _V_: an ECMAScript language value, _argumentsList_: a List of ECMAScript language values, ): either a normal completion containing an ECMAScript language value or a throw completion

An implementation of HostCallJobCallback must conform to the following requirements:

• It must perform and return the result of Call(_jobCallback_.[[Callback]], _V_, _argumentsList_).

The default implementation of HostCallJobCallback performs the following steps when called:

ECMAScript hosts that are not web browsers must use the default implementation of HostCallJobCallback.

HostEnqueueGenericJob ( _job_: a Job Abstract Closure, _realm_: a Realm Record, ): ~unused~

description

It schedules _job_ in the realm _realm_ in the agent signified by _realm_.[[AgentSignifier]] to be performed at some future time. The Abstract Closures used with this algorithm are intended to be scheduled without additional constraints, such as priority and ordering.

An implementation of HostEnqueueGenericJob must conform to the requirements in .

HostEnqueuePromiseJob ( _job_: a Job Abstract Closure, _realm_: a Realm Record or *null*, ): ~unused~

description

It schedules _job_ to be performed at some future time. The Abstract Closures used with this algorithm are intended to be related to the handling of Promises, or otherwise, to be scheduled with equal priority to Promise handling operations.

An implementation of HostEnqueuePromiseJob must conform to the requirements in as well as the following:

• If _realm_ is not *null*, each time _job_ is invoked the implementation must perform implementation-defined steps such that execution is prepared to evaluate ECMAScript code at the time of _job_'s invocation.
• Let _scriptOrModule_ be GetActiveScriptOrModule() at the time HostEnqueuePromiseJob is invoked. If _realm_ is not *null*, each time _job_ is invoked the implementation must perform implementation-defined steps such that _scriptOrModule_ is the active script or module at the time of _job_'s invocation.
• Jobs must run in the same order as the HostEnqueuePromiseJob invocations that scheduled them.

HostEnqueueTimeoutJob ( _timeoutJob_: a Job Abstract Closure, _realm_: a Realm Record, _milliseconds_: a non-negative finite Number, ): ~unused~

description

It schedules _timeoutJob_ in the realm _realm_ in the agent signified by _realm_.[[AgentSignifier]] to be performed after at least _milliseconds_ milliseconds.

An implementation of HostEnqueueTimeoutJob must conform to the requirements in .

AgentSignifier ( ): an agent signifier

AgentCanSuspend ( ): a Boolean

Objectives

This specification does not make any guarantees that any object or symbol will be garbage collected. Objects or symbols which are not live may be released after long periods of time, or never at all. For this reason, this specification uses the term "may" when describing behaviour triggered by garbage collection.

The semantics of WeakRefs and FinalizationRegistrys is based on two operations which happen at particular points in time:

• When `WeakRef.prototype.deref` is called, the referent (if *undefined* is not returned) is kept alive so that subsequent, synchronous accesses also return the same value. This list is reset when synchronous work is done using the ClearKeptObjects abstract operation.
• When an object or symbol which is registered with a FinalizationRegistry becomes unreachable, a call of the FinalizationRegistry's cleanup callback may eventually be made, after synchronous ECMAScript execution completes. The FinalizationRegistry cleanup is performed with the CleanupFinalizationRegistry abstract operation.

Neither of these actions (ClearKeptObjects or CleanupFinalizationRegistry) may interrupt synchronous ECMAScript execution. Because hosts may assemble longer, synchronous ECMAScript execution runs, this specification defers the scheduling of ClearKeptObjects and CleanupFinalizationRegistry to the host environment.

Some ECMAScript implementations include garbage collector implementations which run in the background, including when ECMAScript is idle. Letting the host environment schedule CleanupFinalizationRegistry allows it to resume ECMAScript execution in order to run finalizer work, which may free up held values, reducing overall memory usage.

Liveness

For some set of objects and/or symbols _S_ a hypothetical WeakRef-oblivious execution with respect to _S_ is an execution whereby the abstract operation WeakRefDeref of a WeakRef whose referent is an element of _S_ always returns *undefined*.

At any point during evaluation, a set of objects and/or symbols _S_ is considered live if either of the following conditions is met:

• Any element in _S_ is included in any agent's [[KeptAlive]] List.
• There exists a valid future hypothetical WeakRef-oblivious execution with respect to _S_ that observes the identity of any value in _S_.

Execution

At any time, if a set of objects and/or symbols _S_ is not live, an ECMAScript implementation may perform the following steps atomically:

Host Hooks

[[GetPrototypeOf]] ( ): a normal completion containing either an Object or *null*

for

an ordinary object _O_

[[SetPrototypeOf]] ( _V_: an Object or *null*, ): a normal completion containing a Boolean

for

an ordinary object _O_

[[IsExtensible]] ( ): a normal completion containing a Boolean

for

an ordinary object _O_

[[PreventExtensions]] ( ): a normal completion containing *true*

for

an ordinary object _O_

[[GetOwnProperty]] ( _P_: a property key, ): a normal completion containing either a Property Descriptor or *undefined*

for

an ordinary object _O_

[[DefineOwnProperty]] ( _P_: a property key, _Desc_: a Property Descriptor, ): either a normal completion containing a Boolean or a throw completion

for

an ordinary object _O_

[[HasProperty]] ( _P_: a property key, ): either a normal completion containing a Boolean or a throw completion

for

an ordinary object _O_

[[Get]] ( _P_: a property key, _Receiver_: an ECMAScript language value, ): either a normal completion containing an ECMAScript language value or a throw completion

for

an ordinary object _O_

[[Set]] ( _P_: a property key, _V_: an ECMAScript language value, _Receiver_: an ECMAScript language value, ): either a normal completion containing a Boolean or a throw completion

for

an ordinary object _O_

[[Delete]] ( _P_: a property key, ): either a normal completion containing a Boolean or a throw completion

for

an ordinary object _O_

[[OwnPropertyKeys]] ( ): a normal completion containing a List of property keys

for

an ordinary object _O_

OrdinaryObjectCreate ( _proto_: an Object or *null*, optional _additionalInternalSlotsList_: a List of names of internal slots, ): an Object

description

It is used to specify the runtime creation of new ordinary objects. _additionalInternalSlotsList_ contains the names of additional internal slots that must be defined as part of the object, beyond [[Prototype]] and [[Extensible]]. If _additionalInternalSlotsList_ is not provided, a new empty List is used.

OrdinaryCreateFromConstructor ( _constructor_: a constructor, _intrinsicDefaultProto_: a String, optional _internalSlotsList_: a List of names of internal slots, ): either a normal completion containing an Object or a throw completion

description

It creates an ordinary object whose [[Prototype]] value is retrieved from a constructor's *"prototype"* property, if it exists. Otherwise the intrinsic named by _intrinsicDefaultProto_ is used for [[Prototype]]. _internalSlotsList_ contains the names of additional internal slots that must be defined as part of the object. If _internalSlotsList_ is not provided, a new empty List is used.

GetPrototypeFromConstructor ( _constructor_: a function object, _intrinsicDefaultProto_: a String, ): either a normal completion containing an Object or a throw completion

description

It determines the [[Prototype]] value that should be used to create an object corresponding to a specific constructor. The value is retrieved from the constructor's *"prototype"* property, if it exists. Otherwise the intrinsic named by _intrinsicDefaultProto_ is used for [[Prototype]].

RequireInternalSlot ( _O_: an ECMAScript language value, _internalSlot_: an internal slot name, ): either a normal completion containing ~unused~ or a throw completion

description

It throws an exception unless _O_ is an Object and has the given internal slot.

[[Call]] ( _thisArgument_: an ECMAScript language value, _argumentsList_: a List of ECMAScript language values, ): either a normal completion containing an ECMAScript language value or a throw completion

for

an ECMAScript function object _F_

[[Construct]] ( _argumentsList_: a List of ECMAScript language values, _newTarget_: a constructor, ): either a normal completion containing an Object or a throw completion

for

an ECMAScript function object _F_

OrdinaryFunctionCreate ( _functionPrototype_: an Object, _sourceText_: a sequence of Unicode code points, _ParameterList_: a Parse Node, _Body_: a Parse Node, _thisMode_: ~lexical-this~ or ~non-lexical-this~, _env_: an Environment Record, _privateEnv_: a PrivateEnvironment Record or *null*, ): an ECMAScript function object

description

It is used to specify the runtime creation of a new function with a default [[Call]] internal method and no [[Construct]] internal method (although one may be subsequently added by an operation such as MakeConstructor). _sourceText_ is the source text of the syntactic definition of the function to be created.

AddRestrictedFunctionProperties ( _F_: a function object, _realm_: a Realm Record, ): ~unused~

MakeConstructor ( _F_: an ECMAScript function object or a built-in function object, optional _writablePrototype_: a Boolean, optional _prototype_: an Object, ): ~unused~

description

It converts _F_ into a constructor.

MakeClassConstructor ( _F_: an ECMAScript function object, ): ~unused~

MakeMethod ( _F_: an ECMAScript function object, _homeObject_: an Object, ): ~unused~

description

It configures _F_ as a method.

DefineMethodProperty ( _homeObject_: an Object, _key_: a property key or Private Name, _closure_: a function object, _enumerable_: a Boolean, ): either a normal completion containing either a PrivateElement or ~unused~, or an abrupt completion

SetFunctionName ( _F_: a function object, _name_: a property key or Private Name, optional _prefix_: a String, ): ~unused~

description

It adds a *"name"* property to _F_.

SetFunctionLength ( _F_: a function object, _length_: a non-negative integer or +∞, ): ~unused~

description

It adds a *"length"* property to _F_.

FunctionDeclarationInstantiation ( _func_: an ECMAScript function object, _argumentsList_: a List of ECMAScript language values, ): either a normal completion containing ~unused~ or an abrupt completion

description

_func_ is the function object for which the execution context is being established.

It performs the following steps when called:

[[Call]] ( _thisArgument_: an ECMAScript language value, _argumentsList_: a List of ECMAScript language values, ): either a normal completion containing an ECMAScript language value or a throw completion

for

a built-in function object _F_

[[Construct]] ( _argumentsList_: a List of ECMAScript language values, _newTarget_: a constructor, ): either a normal completion containing an Object or a throw completion

for

a built-in function object _F_ (when the method is present)

BuiltinCallOrConstruct ( _F_: a built-in function object, _thisArgument_: an ECMAScript language value or ~uninitialized~, _argumentsList_: a List of ECMAScript language values, _newTarget_: a constructor or *undefined*, ): either a normal completion containing an ECMAScript language value or a throw completion

CreateBuiltinFunction ( _behaviour_: an Abstract Closure, a set of algorithm steps, or some other definition of a function's behaviour provided in this specification, _length_: a non-negative integer or +∞, _name_: a property key or a Private Name, _additionalInternalSlotsList_: a List of names of internal slots, optional _realm_: a Realm Record, optional _prototype_: an Object or *null*, optional _prefix_: a String, ): a function object

description

_additionalInternalSlotsList_ contains the names of additional internal slots that must be defined as part of the object. This operation creates a built-in function object.

Each built-in function defined in this specification is created by calling the CreateBuiltinFunction abstract operation.

Bound Function Exotic Objects

A bound function exotic object is an exotic object that wraps another function object. A bound function exotic object is callable (it has a [[Call]] internal method and may have a [[Construct]] internal method). Calling a bound function exotic object generally results in a call of its wrapped function.

An object is a bound function exotic object if its [[Call]] and (if applicable) [[Construct]] internal methods use the following implementations, and its other essential internal methods use the definitions found in . These methods are installed in BoundFunctionCreate.

Bound function exotic objects do not have the internal slots of ECMAScript function objects listed in . Instead they have the internal slots listed in , in addition to [[Prototype]] and [[Extensible]].

Array Exotic Objects

An Array is an exotic object that gives special treatment to array index property keys (see ). A property whose property name is an array index is also called an element. Every Array has a non-configurable *"length"* property whose value is always a non-negative integral Number whose mathematical value is strictly less than 2³². The value of the *"length"* property is numerically greater than the name of every own property whose name is an array index; whenever an own property of an Array is created or changed, other properties are adjusted as necessary to maintain this invariant. Specifically, whenever an own property is added whose name is an array index, the value of the *"length"* property is changed, if necessary, to be one more than the numeric value of that array index; and whenever the value of the *"length"* property is changed, every own property whose name is an array index whose value is not smaller than the new length is deleted. This constraint applies only to own properties of an Array and is unaffected by *"length"* or array index properties that may be inherited from its prototypes.

An object is an Array exotic object (or simply, an Array) if its [[DefineOwnProperty]] internal method uses the following implementation, and its other essential internal methods use the definitions found in . These methods are installed in ArrayCreate.

String Exotic Objects

A String object is an exotic object that encapsulates a String value and exposes virtual integer-indexed data properties corresponding to the individual code unit elements of the String value. String exotic objects always have a data property named *"length"* whose value is the length of the encapsulated String value. Both the code unit data properties and the *"length"* property are non-writable and non-configurable.

An object is a String exotic object (or simply, a String object) if its [[GetOwnProperty]], [[DefineOwnProperty]], and [[OwnPropertyKeys]] internal methods use the following implementations, and its other essential internal methods use the definitions found in . These methods are installed in StringCreate.

String exotic objects have the same internal slots as ordinary objects. They also have a [[StringData]] internal slot.

Arguments Exotic Objects

Most ECMAScript functions make an arguments object available to their code. Depending upon the characteristics of the function definition, its arguments object is either an ordinary object or an arguments exotic object. An arguments exotic object is an exotic object whose array index properties map to the formal parameters bindings of an invocation of its associated ECMAScript function.

An object is an arguments exotic object if its internal methods use the following implementations, with the ones not specified here using those found in . These methods are installed in CreateMappedArgumentsObject.

Arguments exotic objects have the same internal slots as ordinary objects. They also have a [[ParameterMap]] internal slot. Ordinary arguments objects also have a [[ParameterMap]] internal slot whose value is always undefined. For ordinary argument objects the [[ParameterMap]] internal slot is only used by `Object.prototype.toString` () to identify them as such.

TypedArray Exotic Objects

A TypedArray is an exotic object that performs special handling of integer index property keys.

TypedArrays have the same internal slots as ordinary objects and additionally [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], [[ContentType]], and [[TypedArrayName]] internal slots.

An object is a TypedArray if its [[GetOwnProperty]], [[HasProperty]], [[DefineOwnProperty]], [[Get]], [[Set]], [[Delete]], and [[OwnPropertyKeys]] internal methods use the definitions in this section, and its other essential internal methods use the definitions found in . These methods are installed by TypedArrayCreate.

Module Namespace Exotic Objects

A module namespace exotic object is an exotic object that exposes the bindings exported from an ECMAScript |Module| (See ). There is a one-to-one correspondence between the String-keyed own properties of a module namespace exotic object and the binding names exported by the |Module|. The exported bindings include any bindings that are indirectly exported using `export *` export items. Each String-valued own property key is the StringValue of the corresponding exported binding name. These are the only String-keyed properties of a module namespace exotic object. Each such property has the attributes { [[Writable]]: *true*, [[Enumerable]]: *true*, [[Configurable]]: *false* }. Module namespace exotic objects are not extensible.

An object is a module namespace exotic object if its [[GetPrototypeOf]], [[SetPrototypeOf]], [[IsExtensible]], [[PreventExtensions]], [[GetOwnProperty]], [[DefineOwnProperty]], [[HasProperty]], [[Get]], [[Set]], [[Delete]], and [[OwnPropertyKeys]] internal methods use the definitions in this section, and its other essential internal methods use the definitions found in . These methods are installed by ModuleNamespaceCreate.

Module namespace exotic objects have the internal slots defined in .

Immutable Prototype Exotic Objects

An immutable prototype exotic object is an exotic object that has a [[Prototype]] internal slot that will not change once it is initialized.

An object is an immutable prototype exotic object if its [[SetPrototypeOf]] internal method uses the following implementation. (Its other essential internal methods may use any implementation, depending on the specific immutable prototype exotic object in question.)

[[GetPrototypeOf]] ( ): either a normal completion containing either an Object or *null*, or a throw completion

for

a Proxy exotic object _O_

[[SetPrototypeOf]] ( _V_: an Object or *null*, ): either a normal completion containing a Boolean or a throw completion

for

a Proxy exotic object _O_

[[IsExtensible]] ( ): either a normal completion containing a Boolean or a throw completion

for

a Proxy exotic object _O_

[[PreventExtensions]] ( ): either a normal completion containing a Boolean or a throw completion

for

a Proxy exotic object _O_

[[GetOwnProperty]] ( _P_: a property key, ): either a normal completion containing either a Property Descriptor or *undefined*, or a throw completion

for

a Proxy exotic object _O_

[[DefineOwnProperty]] ( _P_: a property key, _Desc_: a Property Descriptor, ): either a normal completion containing a Boolean or a throw completion

for

a Proxy exotic object _O_

[[HasProperty]] ( _P_: a property key, ): either a normal completion containing a Boolean or a throw completion

for

a Proxy exotic object _O_

[[Get]] ( _P_: a property key, _Receiver_: an ECMAScript language value, ): either a normal completion containing an ECMAScript language value or a throw completion

for

a Proxy exotic object _O_

[[Set]] ( _P_: a property key, _V_: an ECMAScript language value, _Receiver_: an ECMAScript language value, ): either a normal completion containing a Boolean or a throw completion

for

a Proxy exotic object _O_

[[Delete]] ( _P_: a property key, ): either a normal completion containing a Boolean or a throw completion

for

a Proxy exotic object _O_

[[OwnPropertyKeys]] ( ): either a normal completion containing a List of property keys or a throw completion

for

a Proxy exotic object _O_

[[Call]] ( _thisArgument_: an ECMAScript language value, _argumentsList_: a List of ECMAScript language values, ): either a normal completion containing an ECMAScript language value or a throw completion

for

a Proxy exotic object _O_

[[Construct]] ( _argumentsList_: a List of ECMAScript language values, _newTarget_: a constructor, ): either a normal completion containing an Object or a throw completion

for

a Proxy exotic object _O_

ValidateNonRevokedProxy ( _proxy_: a Proxy exotic object, ): either a normal completion containing ~unused~ or a throw completion

description

It throws a *TypeError* exception if _proxy_ has been revoked.

ProxyCreate ( _target_: an ECMAScript language value, _handler_: an ECMAScript language value, ): either a normal completion containing a Proxy exotic object or a throw completion

description

It is used to specify the creation of new Proxy objects.

Static Semantics: UTF16EncodeCodePoint ( _cp_: a Unicode code point, ): a String

Static Semantics: CodePointsToString ( _text_: a sequence of Unicode code points, ): a String

description

It converts _text_ into a String value, as described in .

Static Semantics: UTF16SurrogatePairToCodePoint ( _lead_: a code unit, _trail_: a code unit, ): a code point

description

Two code units that form a UTF-16 surrogate pair are converted to a code point.

Static Semantics: CodePointAt ( _string_: a String, _position_: a non-negative integer, ): a Record with fields [[CodePoint]] (a code point), [[CodeUnitCount]] (a positive integer), and [[IsUnpairedSurrogate]] (a Boolean)

description

It interprets _string_ as a sequence of UTF-16 encoded code points, as described in , and reads from it a single code point starting with the code unit at index _position_.

Static Semantics: StringToCodePoints ( _string_: a String, ): a List of code points

description

It returns the sequence of Unicode code points that results from interpreting _string_ as UTF-16 encoded Unicode text as described in .

Static Semantics: ParseText ( _sourceText_: a String or a sequence of Unicode code points, _goalSymbol_: a nonterminal in one of the ECMAScript grammars, ): a Parse Node or a non-empty List of *SyntaxError* objects

Directive Prologues and the Use Strict Directive

A Directive Prologue is the longest sequence of |ExpressionStatement|s occurring as the initial |StatementListItem|s or |ModuleItem|s of a |FunctionBody|, a |ScriptBody|, or a |ModuleBody| and where each |ExpressionStatement| in the sequence consists entirely of a |StringLiteral| token followed by a semicolon. The semicolon may appear explicitly or may be inserted by automatic semicolon insertion (). A Directive Prologue may be an empty sequence.

A Use Strict Directive is an |ExpressionStatement| in a Directive Prologue whose |StringLiteral| is either of the exact code point sequences `"use strict"` or `'use strict'`. A Use Strict Directive may not contain an |EscapeSequence| or |LineContinuation|.

A Directive Prologue may contain more than one Use Strict Directive. However, an implementation may issue a warning if this occurs.

Strict Mode Code

An ECMAScript syntactic unit may be processed using either unrestricted or strict mode syntax and semantics (). Code is interpreted as strict mode code in the following situations:

• Global code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive.
• Module code is always strict mode code.
• All parts of a |ClassDeclaration| or a |ClassExpression| are strict mode code.
• Eval code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive or if the call to `eval` is a direct eval that is contained in strict mode code.
• Function code is strict mode code if the associated |FunctionDeclaration|, |FunctionExpression|, |GeneratorDeclaration|, |GeneratorExpression|, |AsyncFunctionDeclaration|, |AsyncFunctionExpression|, |AsyncGeneratorDeclaration|, |AsyncGeneratorExpression|, |MethodDefinition|, |ArrowFunction|, or |AsyncArrowFunction| is contained in strict mode code or if the code that produces the value of the function's [[ECMAScriptCode]] internal slot begins with a Directive Prologue that contains a Use Strict Directive.
• Function code that is supplied as the arguments to the built-in Function, Generator, AsyncFunction, and AsyncGenerator constructors is strict mode code if the last argument is a String that when processed is a |FunctionBody| that begins with a Directive Prologue that contains a Use Strict Directive.

ECMAScript code that is not strict mode code is called non-strict code.

Non-ECMAScript Functions

An ECMAScript implementation may support the evaluation of function exotic objects whose evaluative behaviour is expressed in some host-defined form of executable code other than ECMAScript source text. Whether a function object is defined within ECMAScript code or is a built-in function is not observable from the perspective of ECMAScript code that calls or is called by such a function object.

Identifier Names

Unicode escape sequences are permitted in an |IdentifierName|, where they contribute a single Unicode code point equal to the IdentifierCodePoint of the |UnicodeEscapeSequence|. The `\\` preceding the |UnicodeEscapeSequence| does not contribute any code points. A |UnicodeEscapeSequence| cannot be used to contribute a code point to an |IdentifierName| that would otherwise be invalid. In other words, if a `\\` |UnicodeEscapeSequence| sequence were replaced by the |SourceCharacter| it contributes, the result must still be a valid |IdentifierName| that has the exact same sequence of |SourceCharacter| elements as the original |IdentifierName|. All interpretations of |IdentifierName| within this specification are based upon their actual code points regardless of whether or not an escape sequence was used to contribute any particular code point.

Two |IdentifierName|s that are canonically equivalent according to the Unicode Standard are not equal unless, after replacement of each |UnicodeEscapeSequence|, they are represented by the exact same sequence of code points.

Keywords and Reserved Words

A keyword is a token that matches |IdentifierName|, but also has a syntactic use; that is, it appears literally, in a `fixed width` font, in some syntactic production. The keywords of ECMAScript include `if`, `while`, `async`, `await`, and many others.

A reserved word is an |IdentifierName| that cannot be used as an identifier. Many keywords are reserved words, but some are not, and some are reserved only in certain contexts. `if` and `while` are reserved words. `await` is reserved only inside async functions and modules. `async` is not reserved; it can be used as a variable name or statement label without restriction.

This specification uses a combination of grammatical productions and early error rules to specify which names are valid identifiers and which are reserved words. All tokens in the |ReservedWord| list below, except for `await` and `yield`, are unconditionally reserved. Exceptions for `await` and `yield` are specified in , using parameterized syntactic productions. Lastly, several early error rules restrict the set of valid identifiers. See , , , and . In summary, there are five categories of identifier names:

• Those that are always allowed as identifiers, and are not keywords, such as `Math`, `window`, `toString`, and `_`;

• Those that are never allowed as identifiers, namely the |ReservedWord|s listed below except `await` and `yield`;

• Those that are contextually allowed as identifiers, namely `await` and `yield`;

• Those that are contextually disallowed as identifiers, in strict mode code: `let`, `static`, `implements`, `interface`, `package`, `private`, `protected`, and `public`;

• Those that are always allowed as identifiers, but also appear as keywords within certain syntactic productions, at places where |Identifier| is not allowed: `as`, `async`, `from`, `get`, `meta`, `of`, `set`, and `target`.

The term conditional keyword, or contextual keyword, is sometimes used to refer to the keywords that fall in the last three categories, and thus can be used as identifiers in some contexts and as keywords in others.

Syntax

Null Literals

Syntax

Boolean Literals

Syntax

Numeric Literals

Syntax

The |SourceCharacter| immediately following a |NumericLiteral| must not be an |IdentifierStart| or |DecimalDigit|.

String Literals

Syntax

The definition of the nonterminal |HexDigit| is given in . |SourceCharacter| is defined in .

            function invalid() { "\7"; "use strict"; }
          

Regular Expression Literals

The productions below describe the syntax for a regular expression literal and are used by the input element scanner to find the end of the regular expression literal. The source text comprising the |RegularExpressionBody| and the |RegularExpressionFlags| are subsequently parsed again using the more stringent ECMAScript Regular Expression grammar ().

An implementation may extend the ECMAScript Regular Expression grammar defined in , but it must not extend the |RegularExpressionBody| and |RegularExpressionFlags| productions defined below or the productions used by these productions.

Syntax

Template Literal Lexical Components

Syntax

Rules of Automatic Semicolon Insertion

In the following rules, “token” means the actual recognized lexical token determined using the current lexical goal symbol as described in clause .

There are three basic rules of semicolon insertion:

1. When, as the source text is parsed from left to right, a token (called the offending token) is encountered that is not allowed by any production of the grammar, then a semicolon is automatically inserted before the offending token if one or more of the following conditions is true:

   • The offending token is separated from the previous token by at least one |LineTerminator|.
   • The offending token is `}`.
   • The previous token is `)` and the inserted semicolon would then be parsed as the terminating semicolon of a do-while statement ().
2. When, as the source text is parsed from left to right, the end of the input stream of tokens is encountered and the parser is unable to parse the input token stream as a single instance of the goal nonterminal, then a semicolon is automatically inserted at the end of the input stream.
3. When, as the source text is parsed from left to right, a token is encountered that is allowed by some production of the grammar, but the production is a restricted production and the token would be the first token for a terminal or nonterminal immediately following the annotation “[no |LineTerminator| here]” within the restricted production (and therefore such a token is called a restricted token), and the restricted token is separated from the previous token by at least one |LineTerminator|, then a semicolon is automatically inserted before the restricted token.

However, there is an additional overriding condition on the preceding rules: a semicolon is never inserted automatically if the semicolon would then be parsed as an empty statement or if that semicolon would become one of the two semicolons in the header of a `for` statement (see ).

Examples of Automatic Semicolon Insertion

The source

{ 1 2 } 3

is not a valid sentence in the ECMAScript grammar, even with the automatic semicolon insertion rules. In contrast, the source

        { 1
        2 } 3
      

is also not a valid ECMAScript sentence, but is transformed by automatic semicolon insertion into the following:

        { 1
        ;2 ;} 3;
      

which is a valid ECMAScript sentence.

The source

        for (a; b
        )
      

is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion because the semicolon is needed for the header of a `for` statement. Automatic semicolon insertion never inserts one of the two semicolons in the header of a `for` statement.

The source

        return
        a + b
      

is transformed by automatic semicolon insertion into the following:

        return;
        a + b;
      

The source

        a = b
        ++c
      

is transformed by automatic semicolon insertion into the following:

        a = b;
        ++c;
      

The source

        if (a > b)
        else c = d
      

is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion before the `else` token, even though no production of the grammar applies at that point, because an automatically inserted semicolon would then be parsed as an empty statement.

The source

        a = b + c
        (d + e).print()
      

is not transformed by automatic semicolon insertion, because the parenthesized expression that begins the second line can be interpreted as an argument list for a function call:

a = b + c(d + e).print()

In the circumstance that an assignment statement must begin with a left parenthesis, it is a good idea for the programmer to provide an explicit semicolon at the end of the preceding statement rather than to rely on automatic semicolon insertion.

Interesting Cases of Automatic Semicolon Insertion

ECMAScript programs can be written in a style with very few semicolons by relying on automatic semicolon insertion. As described above, semicolons are not inserted at every newline, and automatic semicolon insertion can depend on multiple tokens across line terminators.

As new syntactic features are added to ECMAScript, additional grammar productions could be added that cause lines relying on automatic semicolon insertion preceding them to change grammar productions when parsed.

For the purposes of this section, a case of automatic semicolon insertion is considered interesting if it is a place where a semicolon may or may not be inserted, depending on the source text which precedes it. The rest of this section describes a number of interesting cases of automatic semicolon insertion in this version of ECMAScript.

Static Semantics: Early Errors

• It is a Syntax Error if IsStrict(this production) is *true* and the StringValue of |Identifier| is either *"arguments"* or *"eval"*.

• It is a Syntax Error if IsStrict(this production) is *true*.

• It is a Syntax Error if the goal symbol of the syntactic grammar is |Module|.

• It is a Syntax Error if this production has a _[Yield] parameter.

• It is a Syntax Error if this production has an _[Await] parameter.

• It is a Syntax Error if this production has a _[Yield] parameter and StringValue of |Identifier| is *"yield"*.
• It is a Syntax Error if this production has an _[Await] parameter and StringValue of |Identifier| is *"await"*.

• It is a Syntax Error if IsStrict(this phrase) is *true* and the StringValue of |IdentifierName| is one of *"implements"*, *"interface"*, *"let"*, *"package"*, *"private"*, *"protected"*, *"public"*, *"static"*, or *"yield"*.
• It is a Syntax Error if the goal symbol of the syntactic grammar is |Module| and the StringValue of |IdentifierName| is *"await"*.
• It is a Syntax Error if the StringValue of |IdentifierName| is the StringValue of any |ReservedWord| except for `yield` or `await`.

Static Semantics: StringValue ( ): a String

Runtime Semantics: Evaluation

The `this` Keyword

Identifier Reference

See for |IdentifierReference|.

Literals

Syntax

Array Initializer

Array elements may be elided at the beginning, middle or end of the element list. Whenever a comma in the element list is not preceded by an |AssignmentExpression| (i.e., a comma at the beginning or after another comma), the missing array element contributes to the length of the Array and increases the index of subsequent elements. Elided array elements are not defined. If an element is elided at the end of an array, that element does not contribute to the length of the Array.

Syntax

Object Initializer

Syntax

Function Defining Expressions

See for PrimaryExpression : FunctionExpression.

See for PrimaryExpression : GeneratorExpression.

See for PrimaryExpression : ClassExpression.

See for PrimaryExpression : AsyncFunctionExpression.

See for PrimaryExpression : AsyncGeneratorExpression.

Regular Expression Literals

Syntax

See .

Template Literals

Syntax