A specification type corresponds to meta-values that are used within algorithms to describe the semantics of ECMAScript language constructs and ECMAScript language types. The specification types include Reference, List, Completion, Property Descriptor, Lexical Environment, Environment Record, and Data Block. Specification type values are specification artefacts that do not necessarily correspond to any specific entity within an ECMAScript implementation. Specification type values may be used to describe intermediate results of ECMAScript expression evaluation but such values cannot be stored as properties of objects or values of ECMAScript language variables.
+ + +The List type is used to explain the evaluation of argument lists (see
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 « ».
+The Record type is used to describe data aggregations within the algorithms of this specification. A Record type value consists of one or more named fields. The value of each field is either an ECMAScript value or an abstract value represented by a name associated with the Record type. Field names are always enclosed in double brackets, for example [[Value]].
+For notational convenience within this specification, an object literal-like syntax can be used to express a Record value. For example, {[[Field1]]: 42, [[Field2]]: *false*, [[Field3]]: ~empty~} defines a Record value that has three fields, each of which is initialized to a specific value. Field name order is not significant. Any fields that are not explicitly listed are considered to be absent.
+In specification text and algorithms, dot notation may be used to refer to a specific field of a Record value. For example, if R is the record shown in the previous paragraph then R.[[Field2]] is shorthand for “the field of R named [[Field2]]”.
+Schema for commonly used Record field combinations may be named, and that name may be used as a prefix to a literal Record value to identify the specific kind of aggregations that is being described. For example: PropertyDescriptor{[[Value]]: 42, [[Writable]]: *false*, [[Configurable]]: *true*}.
+The Set type is used to explain a collection of unordered elements for use in the memory model. 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:
+The two properties above are called, in order, irreflexivity and transitivity.
+A strict total order is a Relation value _R_ that satisfies the following.
+For all _a_, _b_, and _c_ in _R_'s domain:
+The three properties above are called, in order, totality, irreflexivity, and transitivity.
+The Completion type is a Record 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.
+Values of the Completion type are Record values whose fields are defined as by
| + Field Name + | ++ Value + | ++ Meaning + | +
|---|---|---|
| + [[Type]] + | ++ One of ~normal~, ~break~, ~continue~, ~return~, or ~throw~ + | ++ The type of completion that occurred. + | +
| + [[Value]] + | ++ any ECMAScript language value or ~empty~ + | ++ The value that was produced. + | +
| + [[Target]] + | ++ any ECMAScript string or ~empty~ + | ++ The target label for directed control transfers. + | +
The term “abrupt completion” refers to any completion with a [[Type]] value other than ~normal~.
+ + +The abstract operation NormalCompletion with a single _argument_, such as:
+Is a shorthand that is defined as follows:
+The abstract operation UpdateEmpty with arguments _completionRecord_ and _value_ performs the following steps:
+The Reference 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.
+A Reference is a resolved name or property binding. A Reference consists of three components, the base value component, the referenced name component, and the Boolean-valued strict reference flag. The base value component is either *undefined*, an Object, a Boolean, a String, a Symbol, a Number, or an Environment Record. A base value component of *undefined* indicates that the Reference could not be resolved to a binding. The referenced name component is a String or Symbol value.
+A Super Reference is a Reference that is used to represents a name binding that was expressed using the super keyword. A Super Reference has an additional thisValue component, and its base value component will never be an Environment Record.
+The following abstract operations are used in this specification to operate on references:
+ +The object that may be created in step 5.a.ii is not accessible outside of the above abstract operation and the ordinary object [[Get]] internal method. An implementation might choose to avoid the actual creation of the object.
+The object that may be created in step 6.a.ii is not accessible outside of the above algorithm and the ordinary object [[Set]] internal method. An implementation might choose to avoid the actual creation of that object.
+The Property Descriptor type is used to explain the manipulation and reification of Object property attributes. Values of the Property Descriptor type are Records. Each field's name is an attribute name and its value is a corresponding attribute value as specified in
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. A generic Property Descriptor is a Property Descriptor value that is neither a data Property Descriptor nor an accessor 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 fields that correspond to the property attributes defined in either
The following abstract operations are used in this specification to operate upon Property Descriptor values:
+ + +When the abstract operation IsAccessorDescriptor is called with Property Descriptor _Desc_, the following steps are taken:
+When the abstract operation IsDataDescriptor is called with Property Descriptor _Desc_, the following steps are taken:
+When the abstract operation IsGenericDescriptor is called with Property Descriptor _Desc_, the following steps are taken:
+When the abstract operation FromPropertyDescriptor is called with Property Descriptor _Desc_, the following steps are taken:
+When the abstract operation ToPropertyDescriptor is called with object _Obj_, the following steps are taken:
+When the abstract operation CompletePropertyDescriptor is called with Property Descriptor _Desc_, the following steps are taken:
+The Lexical Environment and Environment Record types are used to explain the behaviour of name resolution in nested functions and blocks. These types and the operations upon them are defined in
The Data Block specification type is used to describe a distinct and mutable sequence of byte-sized (8 bit) numeric values. 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 3rd 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:
+ + +When the abstract operation CreateByteDataBlock is called with integer argument _size_, the following steps are taken:
+When the abstract operation CreateSharedByteDataBlock is called with integer argument _size_, the following steps are taken:
+When the abstract operation CopyDataBlockBytes is called, the following steps are taken:
+Algorithms within this specification manipulate values each of which has an associated type. The possible value types are exactly those defined in this clause. Types are further subclassified into ECMAScript language types and specification types.
+Within this specification, the notation “Type(_x_)” is used as shorthand for “the type of _x_” where “type” refers to the ECMAScript language and specification types defined in this clause. When the term “empty” is used as if it was naming a value, it is equivalent to saying “no value of any type”.
+ + +An ECMAScript language type corresponds to values that are directly manipulated by an ECMAScript programmer using the ECMAScript language. The ECMAScript language types are Undefined, Null, Boolean, String, Symbol, Number, and Object. An ECMAScript language value is a value that is characterized by an ECMAScript language type.
+ + +The Undefined type has exactly one value, called *undefined*. Any variable that has not been assigned a value has the value *undefined*.
+The Null type has exactly one value, called *null*.
+The Boolean type represents a logical entity having two values, called *true* and *false*.
+The String type is the set of all ordered sequences of zero or more 16-bit unsigned integer values (“elements”) up to a maximum length of 253-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 nonnegative integers. The first element (if any) is at index 0, the next element (if any) at index 1, and so on. The length of a String is the number of elements (i.e., 16-bit values) within it. The empty String has length zero and therefore contains no elements.
+Where ECMAScript operations interpret String values, each element is interpreted as a single UTF-16 code unit. However, ECMAScript does not place any restrictions or requirements on the sequence of code units in a String value, so they may be ill-formed when interpreted as UTF-16 code unit sequences. Operations that do not interpret String contents treat them as sequences of undifferentiated 16-bit unsigned integers. The function `String.prototype.normalize` (see
The rationale behind this design was to keep the implementation of Strings as simple and high-performing as possible. If ECMAScript source text is in Normalized Form C, string literals are guaranteed to also be normalized, as long as they do not contain any Unicode escape sequences.
+Some operations interpret String contents as UTF-16 encoded Unicode code points. In that case the interpretation is:
+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 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.
+ + +Well-known symbols are built-in Symbol values that are explicitly referenced by algorithms of this specification. They are typically used as the keys of properties whose values serve as extension points of a specification algorithm. Unless otherwise specified, well-known symbols values are shared by all realms (
Within this specification a well-known symbol is referred to by using a notation of the form @@name, where “name” is one of the values listed in
| + Specification Name + | ++ [[Description]] + | ++ Value and Purpose + | +
|---|---|---|
| + @@hasInstance + | ++ `"Symbol.hasInstance"` + | ++ A method that determines if a constructor object recognizes an object as one of the constructor's instances. Called by the semantics of the `instanceof` operator. + | +
| + @@isConcatSpreadable + | ++ `"Symbol.isConcatSpreadable"` + | +
+ A Boolean valued property that if true indicates that an object should be flattened to its array elements by |
+
| + @@iterator + | ++ `"Symbol.iterator"` + | ++ A method that returns the default Iterator for an object. Called by the semantics of the for-of statement. + | +
| + @@match + | ++ `"Symbol.match"` + | +
+ A regular expression method that matches the regular expression against a string. Called by the |
+
| + @@replace + | ++ `"Symbol.replace"` + | +
+ A regular expression method that replaces matched substrings of a string. Called by the |
+
| + @@search + | ++ `"Symbol.search"` + | +
+ A regular expression method that returns the index within a string that matches the regular expression. Called by the |
+
| + @@species + | ++ `"Symbol.species"` + | ++ A function valued property that is the constructor function that is used to create derived objects. + | +
| + @@split + | ++ `"Symbol.split"` + | +
+ A regular expression method that splits a string at the indices that match the regular expression. Called by the |
+
| + @@toPrimitive + | ++ `"Symbol.toPrimitive"` + | ++ A method that converts an object to a corresponding primitive value. Called by the ToPrimitive abstract operation. + | +
| + @@toStringTag + | ++ `"Symbol.toStringTag"` + | +
+ A String valued property that is used in the creation of the default string description of an object. Accessed by the built-in method |
+
| + @@unscopables + | ++ `"Symbol.unscopables"` + | ++ An object valued property whose own and inherited property names are property names that are excluded from the `with` environment bindings of the associated object. + | +
The Number type has exactly 18437736874454810627 (that is,
The bit pattern that might be observed in an ArrayBuffer (see
There are two other special values, called *positive Infinity* and *negative Infinity*. For brevity, these values are also referred to for expository purposes by the symbols *+∞* and *-∞*, respectively. (Note that these two infinite Number values are produced by the program expressions `+Infinity` (or simply `Infinity`) and `-Infinity`.)
+The other 18437736874454810624 (that is,
Note that there is both a *positive zero* and a *negative zero*. For brevity, these values are also referred to for expository purposes by the symbols *+0* and *-0*, respectively. (Note that these two different zero Number values are produced by the program expressions `+0` (or simply `0`) and `-0`.)
+The 18437736874454810622 (that is,
18428729675200069632 (that is,
where _s_ is +1 or -1, _m_ is a positive integer less than 253 but not less than 252, and _e_ is an integer ranging from -1074 to 971, inclusive.
+The remaining 9007199254740990 (that is,
where _s_ is +1 or -1, _m_ is a positive integer less than 252, and _e_ is -1074.
+Note that all the positive and negative integers whose magnitude is no greater than 253 are representable in the Number type (indeed, the integer 0 has two representations, *+0* and *-0*).
+A finite number has an odd significand if it is nonzero and the integer _m_ used to express it (in one of the two forms shown above) is odd. Otherwise, it has an even significand.
+In this specification, the phrase “the Number value for _x_” where _x_ represents an exact real mathematical quantity (which might even be an irrational number such as π) means a Number value chosen in the following manner. Consider the set of all finite values of the Number type, with *-0* removed and with two additional values added to it that are not representable in the Number type, namely 21024 (which is
Some ECMAScript operators deal only with integers in specific ranges such as
An Object is logically a collection of properties. Each property is either a data property, or an accessor property:
+Properties are identified using key values. A property key value is either an ECMAScript String value or a Symbol value. All String and Symbol values, including the empty string, are valid as property keys. A property name is a property key that is a String value.
+An integer index is a String-valued property key that is a canonical numeric String (see
Property keys are used to access properties and their values. There are two kinds of access for properties: get and set, corresponding to value retrieval and assignment, respectively. The properties accessible via get and set access includes both own properties that are a direct part of an object and inherited properties which are provided by another associated object via a property inheritance relationship. Inherited properties may be either own or inherited properties of the associated object. Each own property of an object must each have a key value that is distinct from the key values of the other own properties of that object.
+All objects are logically collections of properties, but there are multiple forms of objects that differ in their semantics for accessing and manipulating their properties. Ordinary objects are the most common form of objects and have the default object semantics. An exotic object is any form of object whose property semantics differ in any way from the default semantics.
+ + +Attributes are used in this specification to define and explain the state of Object properties. A data property associates a key value with the attributes listed in
| + Attribute Name + | ++ Value Domain + | ++ Description + | +
|---|---|---|
| + [[Value]] + | ++ Any ECMAScript language type + | ++ The value retrieved by a get access of the property. + | +
| + [[Writable]] + | ++ Boolean + | ++ If *false*, attempts by ECMAScript code to change the property's [[Value]] attribute using [[Set]] will not succeed. + | +
| + [[Enumerable]] + | ++ Boolean + | +
+ If *true*, the property will be enumerated by a for-in enumeration (see |
+
| + [[Configurable]] + | ++ Boolean + | ++ If *false*, attempts to delete the property, change the property to be an accessor property, or change its attributes (other than [[Value]], or changing [[Writable]] to *false*) will fail. + | +
An accessor property associates a key value with the attributes listed in
| + Attribute Name + | ++ Value Domain + | ++ Description + | +
|---|---|---|
| + [[Get]] + | ++ Object | Undefined + | +
+ If the value is an Object it must be a function object. The function's [[Call]] internal method ( |
+
| + [[Set]] + | ++ Object | Undefined + | +
+ If the value is an Object it must be a function object. The function's [[Call]] internal method ( |
+
| + [[Enumerable]] + | ++ Boolean + | +
+ If *true*, the property is to be enumerated by a for-in enumeration (see |
+
| + [[Configurable]] + | ++ Boolean + | ++ If *false*, attempts to delete the property, change the property to be a data property, or change its attributes will fail. + | +
If the initial values of a property's attributes are not explicitly specified by this specification, the default value defined in
| + Attribute Name + | ++ Default Value + | +
|---|---|
| + [[Value]] + | ++ *undefined* + | +
| + [[Get]] + | ++ *undefined* + | +
| + [[Set]] + | ++ *undefined* + | +
| + [[Writable]] + | ++ *false* + | +
| + [[Enumerable]] + | ++ *false* + | +
| + [[Configurable]] + | ++ *false* + | +
The actual semantics of objects, in ECMAScript, are specified via algorithms called internal methods. Each object in an ECMAScript engine is associated with a set of internal methods that defines its runtime behaviour. These internal methods are not part of the ECMAScript language. They are defined by this specification purely for expository purposes. However, each object within an implementation of ECMAScript must behave as specified by the internal methods associated with it. The exact manner in which this is accomplished is determined by the implementation.
+Internal method names are polymorphic. This means that different object values may perform different algorithms when a common internal method name is invoked upon them. That actual object upon which an internal method is invoked is the “target” of the invocation. If, at runtime, the implementation of an algorithm attempts to use an internal method of an object that the object does not support, a *TypeError* exception is thrown.
+Internal slots correspond to internal state that is associated with objects and used by various ECMAScript specification algorithms. Internal slots are not object properties and they are not inherited. Depending upon the specific internal slot specification, such state may consist of values of any ECMAScript language type or of specific ECMAScript specification type values. Unless explicitly specified otherwise, internal slots are allocated as part of the process of creating an object and may not be dynamically added to an object. Unless specified otherwise, the initial value of an internal slot is the value *undefined*. Various algorithms within this specification create objects that have internal slots. However, the ECMAScript language provides no direct way to associate internal slots with an object.
+Internal methods and internal slots are identified within this specification using names enclosed in double square brackets [[ ]].
+The “Signature” column of
| + Internal Method + | ++ Signature + | ++ Description + | +
|---|---|---|
| + [[GetPrototypeOf]] + | ++ ( ) → Object | Null + | ++ Determine the object that provides inherited properties for this object. A *null* value indicates that there are no inherited properties. + | +
| + [[SetPrototypeOf]] + | ++ (Object | Null) → Boolean + | ++ Associate this object with another object that provides inherited properties. Passing *null* indicates that there are no inherited properties. Returns *true* indicating that the operation was completed successfully or *false* indicating that the operation was not successful. + | +
| + [[IsExtensible]] + | ++ ( ) → Boolean + | ++ Determine whether it is permitted to add additional properties to this object. + | +
| + [[PreventExtensions]] + | ++ ( ) → Boolean + | ++ Control whether new properties may be added to this object. Returns *true* if the operation was successful or *false* if the operation was unsuccessful. + | +
| + [[GetOwnProperty]] + | ++ (_propertyKey_) → Undefined | Property Descriptor + | ++ Return a Property Descriptor for the own property of this object whose key is _propertyKey_, or *undefined* if no such property exists. + | +
| + [[DefineOwnProperty]] + | ++ (_propertyKey_, _PropertyDescriptor_) → Boolean + | ++ Create or alter the own property, whose key is _propertyKey_, to have the state described by _PropertyDescriptor_. Return *true* if that property was successfully created/updated or *false* if the property could not be created or updated. + | +
| + [[HasProperty]] + | ++ (_propertyKey_) → Boolean + | ++ Return a Boolean value indicating whether this object already has either an own or inherited property whose key is _propertyKey_. + | +
| + [[Get]] + | ++ (_propertyKey_, _Receiver_) → any + | ++ Return the value of the property whose key is _propertyKey_ from this object. If any ECMAScript code must be executed to retrieve the property value, _Receiver_ is used as the *this* value when evaluating the code. + | +
| + [[Set]] + | ++ (_propertyKey_, _value_, _Receiver_) → Boolean + | ++ Set the value of the property whose key is _propertyKey_ to _value_. If any ECMAScript code must be executed to set the property value, _Receiver_ is used as the *this* value when evaluating the code. Returns *true* if the property value was set or *false* if it could not be set. + | +
| + [[Delete]] + | ++ (_propertyKey_) → Boolean + | ++ Remove the own property whose key is _propertyKey_ from this object. Return *false* if the property was not deleted and is still present. Return *true* if the property was deleted or is not present. + | +
| + [[OwnPropertyKeys]] + | ++ ( ) → List of propertyKey + | ++ Return a List whose elements are all of the own property keys for the object. + | +
| + Internal Method + | ++ Signature + | ++ Description + | +
|---|---|---|
| + [[Call]] + | ++ (any, a List of any) → any + | ++ Executes code associated with this object. Invoked via a function call expression. The arguments to the internal method are a *this* value and a list containing the arguments passed to the function by a call expression. Objects that implement this internal method are callable. + | +
| + [[Construct]] + | ++ (a List of any, Object) → Object + | ++ Creates an object. Invoked via the `new` or `super` operators. The first argument to the internal method is a list containing the arguments of the operator. The second argument is the object to which the `new` operator was initially applied. Objects that implement this internal method are called constructors. A function object is not necessarily a constructor and such non-constructor function objects do not have a [[Construct]] internal method. + | +
The semantics of the essential internal methods for ordinary objects and standard exotic objects are specified in clause
The Internal Methods of Objects of an ECMAScript engine must conform to the list of invariants specified below. Ordinary ECMAScript Objects as well as all standard exotic objects in this specification maintain these invariants. ECMAScript Proxy objects maintain these invariants by means of runtime checks on the result of traps invoked on the [[ProxyHandler]] object.
+Any implementation provided exotic objects must also maintain these invariants for those objects. Violation of these invariants may cause ECMAScript code to have unpredictable behaviour and create security issues. However, violation of these invariants must never compromise the memory safety of an implementation.
+An implementation must not allow these invariants to be circumvented in any manner such as by providing alternative interfaces that implement the functionality of the essential internal methods without enforcing their invariants.
+An object's prototype chain should have finite length (that is, starting from any object, recursively applying the [[GetPrototypeOf]] internal method to its result should eventually lead to the value null). However, this requirement is not enforceable as an object level invariant if the prototype chain includes any exotic objects that do not use the ordinary object definition of [[GetPrototypeOf]]. Such a circular prototype chain may result in infinite loops when accessing object properties.
+As a consequence of the third invariant, if a property is described as a data property and it may return different values over time, then either or both of the Desc.[[Writable]] and Desc.[[Configurable]] attributes must be true even if no mechanism to change the value is exposed via the other internal methods.
+[[DefineOwnProperty]] must return false if P has previously been observed as a non-configurable own property of the target, unless either:
+Well-known intrinsics are built-in objects that are explicitly referenced by the algorithms of this specification and which usually have realm-specific identities. Unless otherwise specified each intrinsic object actually corresponds to a set of similar objects, one per realm.
+Within this specification a reference such as %name% means the intrinsic object, associated with the current realm, corresponding to the name. Determination of the current realm and its intrinsics is described in
| + Intrinsic Name + | ++ Global Name + | ++ ECMAScript Language Association + | +
|---|---|---|
| + %Array% + | ++ `Array` + | +
+ The `Array` constructor ( |
+
| + %ArrayBuffer% + | ++ `ArrayBuffer` + | +
+ The `ArrayBuffer` constructor ( |
+
| + %ArrayBufferPrototype% + | ++ `ArrayBuffer.prototype` + | ++ The initial value of the `prototype` data property of %ArrayBuffer%. + | +
| + %ArrayIteratorPrototype% + | ++ | +
+ The prototype of Array iterator objects ( |
+
| + %ArrayPrototype% + | ++ `Array.prototype` + | +
+ The initial value of the `prototype` data property of %Array% ( |
+
| + %ArrayProto_entries% + | ++ `Array.prototype.entries` + | +
+ The initial value of the `entries` data property of %ArrayPrototype% ( |
+
| + %ArrayProto_forEach% + | ++ `Array.prototype.forEach` + | +
+ The initial value of the `forEach` data property of %ArrayPrototype% ( |
+
| + %ArrayProto_keys% + | ++ `Array.prototype.keys` + | +
+ The initial value of the `keys` data property of %ArrayPrototype% ( |
+
| + %ArrayProto_values% + | ++ `Array.prototype.values` + | +
+ The initial value of the `values` data property of %ArrayPrototype% ( |
+
| + %AsyncFunction% + | ++ | +
+ The constructor of async function objects ( |
+
| + %AsyncFunctionPrototype% + | ++ | ++ The initial value of the `prototype` data property of %AsyncFunction% + | +
| + %Atomics% + | ++ `Atomics` + | +
+ The `Atomics` object ( |
+
| + %Boolean% + | ++ `Boolean` + | +
+ The `Boolean` constructor ( |
+
| + %BooleanPrototype% + | ++ `Boolean.prototype` + | +
+ The initial value of the `prototype` data property of %Boolean% ( |
+
| + %DataView% + | ++ `DataView` + | +
+ The `DataView` constructor ( |
+
| + %DataViewPrototype% + | ++ `DataView.prototype` + | ++ The initial value of the `prototype` data property of %DataView% + | +
| + %Date% + | ++ `Date` + | +
+ The `Date` constructor ( |
+
| + %DatePrototype% + | ++ `Date.prototype` + | ++ The initial value of the `prototype` data property of %Date%. + | +
| + %decodeURI% + | ++ `decodeURI` + | +
+ The `decodeURI` function ( |
+
| + %decodeURIComponent% + | ++ `decodeURIComponent` + | +
+ The `decodeURIComponent` function ( |
+
| + %encodeURI% + | ++ `encodeURI` + | +
+ The `encodeURI` function ( |
+
| + %encodeURIComponent% + | ++ `encodeURIComponent` + | +
+ The `encodeURIComponent` function ( |
+
| + %Error% + | ++ `Error` + | +
+ The `Error` constructor ( |
+
| + %ErrorPrototype% + | ++ `Error.prototype` + | ++ The initial value of the `prototype` data property of %Error% + | +
| + %eval% + | ++ `eval` + | +
+ The `eval` function ( |
+
| + %EvalError% + | ++ `EvalError` + | +
+ The `EvalError` constructor ( |
+
| + %EvalErrorPrototype% + | ++ `EvalError.prototype` + | ++ The initial value of the `prototype` data property of %EvalError% + | +
| + %Float32Array% + | ++ `Float32Array` + | +
+ The `Float32Array` constructor ( |
+
| + %Float32ArrayPrototype% + | ++ `Float32Array.prototype` + | ++ The initial value of the `prototype` data property of %Float32Array% + | +
| + %Float64Array% + | ++ `Float64Array` + | +
+ The `Float64Array` constructor ( |
+
| + %Float64ArrayPrototype% + | ++ `Float64Array.prototype` + | ++ The initial value of the `prototype` data property of %Float64Array% + | +
| + %Function% + | ++ `Function` + | +
+ The `Function` constructor ( |
+
| + %FunctionPrototype% + | ++ `Function.prototype` + | ++ The initial value of the `prototype` data property of %Function% + | +
| + %Generator% + | ++ | ++ The initial value of the `prototype` data property of %GeneratorFunction% + | +
| + %GeneratorFunction% + | ++ | +
+ The constructor of generator objects ( |
+
| + %GeneratorPrototype% + | ++ | ++ The initial value of the `prototype` data property of %Generator% + | +
| + %Int8Array% + | ++ `Int8Array` + | +
+ The `Int8Array` constructor ( |
+
| + %Int8ArrayPrototype% + | ++ `Int8Array.prototype` + | ++ The initial value of the `prototype` data property of %Int8Array% + | +
| + %Int16Array% + | ++ `Int16Array` + | +
+ The `Int16Array` constructor ( |
+
| + %Int16ArrayPrototype% + | ++ `Int16Array.prototype` + | ++ The initial value of the `prototype` data property of %Int16Array% + | +
| + %Int32Array% + | ++ `Int32Array` + | +
+ The `Int32Array` constructor ( |
+
| + %Int32ArrayPrototype% + | ++ `Int32Array.prototype` + | ++ The initial value of the `prototype` data property of %Int32Array% + | +
| + %isFinite% + | ++ `isFinite` + | +
+ The `isFinite` function ( |
+
| + %isNaN% + | ++ `isNaN` + | +
+ The `isNaN` function ( |
+
| + %IteratorPrototype% + | ++ | ++ An object that all standard built-in iterator objects indirectly inherit from + | +
| + %JSON% + | ++ `JSON` + | +
+ The `JSON` object ( |
+
| + %JSONParse% + | ++ `JSON.parse` + | ++ The initial value of the `parse` data property of %JSON% + | +
| + %Map% + | ++ `Map` + | +
+ The `Map` constructor ( |
+
| + %MapIteratorPrototype% + | ++ | +
+ The prototype of Map iterator objects ( |
+
| + %MapPrototype% + | ++ `Map.prototype` + | ++ The initial value of the `prototype` data property of %Map% + | +
| + %Math% + | ++ `Math` + | +
+ The `Math` object ( |
+
| + %Number% + | ++ `Number` + | +
+ The `Number` constructor ( |
+
| + %NumberPrototype% + | ++ `Number.prototype` + | ++ The initial value of the `prototype` data property of %Number% + | +
| + %Object% + | ++ `Object` + | +
+ The `Object` constructor ( |
+
| + %ObjectPrototype% + | ++ `Object.prototype` + | +
+ The initial value of the `prototype` data property of %Object% ( |
+
| + %ObjProto_toString% + | ++ `Object.prototype.toString` + | +
+ The initial value of the `toString` data property of %ObjectPrototype% ( |
+
| + %ObjProto_valueOf% + | ++ `Object.prototype.valueOf` + | +
+ The initial value of the `valueOf` data property of %ObjectPrototype% ( |
+
| + %parseFloat% + | ++ `parseFloat` + | +
+ The `parseFloat` function ( |
+
| + %parseInt% + | ++ `parseInt` + | +
+ The `parseInt` function ( |
+
| + %Promise% + | ++ `Promise` + | +
+ The `Promise` constructor ( |
+
| + %PromisePrototype% + | ++ `Promise.prototype` + | ++ The initial value of the `prototype` data property of %Promise% + | +
| + %PromiseProto_then% + | ++ `Promise.prototype.then` + | +
+ The initial value of the `then` data property of %PromisePrototype% ( |
+
| + %Promise_all% + | ++ `Promise.all` + | +
+ The initial value of the `all` data property of %Promise% ( |
+
| + %Promise_reject% + | ++ `Promise.reject` + | +
+ The initial value of the `reject` data property of %Promise% ( |
+
| + %Promise_resolve% + | ++ `Promise.resolve` + | +
+ The initial value of the `resolve` data property of %Promise% ( |
+
| + %Proxy% + | ++ `Proxy` + | +
+ The `Proxy` constructor ( |
+
| + %RangeError% + | ++ `RangeError` + | +
+ The `RangeError` constructor ( |
+
| + %RangeErrorPrototype% + | ++ `RangeError.prototype` + | ++ The initial value of the `prototype` data property of %RangeError% + | +
| + %ReferenceError% + | ++ `ReferenceError` + | +
+ The `ReferenceError` constructor ( |
+
| + %ReferenceErrorPrototype% + | ++ `ReferenceError.prototype` + | ++ The initial value of the `prototype` data property of %ReferenceError% + | +
| + %Reflect% + | ++ `Reflect` + | +
+ The `Reflect` object ( |
+
| + %RegExp% + | ++ `RegExp` + | +
+ The `RegExp` constructor ( |
+
| + %RegExpPrototype% + | ++ `RegExp.prototype` + | ++ The initial value of the `prototype` data property of %RegExp% + | +
| + %Set% + | ++ `Set` + | +
+ The `Set` constructor ( |
+
| + %SetIteratorPrototype% + | ++ | +
+ The prototype of Set iterator objects ( |
+
| + %SetPrototype% + | ++ `Set.prototype` + | ++ The initial value of the `prototype` data property of %Set% + | +
| + %SharedArrayBuffer% + | ++ `SharedArrayBuffer` + | +
+ The `SharedArrayBuffer` constructor ( |
+
| + %SharedArrayBufferPrototype% + | ++ `SharedArrayBuffer.prototype` + | ++ The initial value of the `prototype` data property of %SharedArrayBuffer% + | +
| + %String% + | ++ `String` + | +
+ The `String` constructor ( |
+
| + %StringIteratorPrototype% + | ++ | +
+ The prototype of String iterator objects ( |
+
| + %StringPrototype% + | ++ `String.prototype` + | ++ The initial value of the `prototype` data property of %String% + | +
| + %Symbol% + | ++ `Symbol` + | +
+ The `Symbol` constructor ( |
+
| + %SymbolPrototype% + | ++ `Symbol.prototype` + | +
+ The initial value of the `prototype` data property of %Symbol% ( |
+
| + %SyntaxError% + | ++ `SyntaxError` + | +
+ The `SyntaxError` constructor ( |
+
| + %SyntaxErrorPrototype% + | ++ `SyntaxError.prototype` + | ++ The initial value of the `prototype` data property of %SyntaxError% + | +
| + %ThrowTypeError% + | ++ | ++ A function object that unconditionally throws a new instance of %TypeError% + | +
| + %TypedArray% + | ++ | +
+ The super class of all typed Array constructors ( |
+
| + %TypedArrayPrototype% + | ++ | ++ The initial value of the `prototype` data property of %TypedArray% + | +
| + %TypeError% + | ++ `TypeError` + | +
+ The `TypeError` constructor ( |
+
| + %TypeErrorPrototype% + | ++ `TypeError.prototype` + | ++ The initial value of the `prototype` data property of %TypeError% + | +
| + %Uint8Array% + | ++ `Uint8Array` + | +
+ The `Uint8Array` constructor ( |
+
| + %Uint8ArrayPrototype% + | ++ `Uint8Array.prototype` + | ++ The initial value of the `prototype` data property of %Uint8Array% + | +
| + %Uint8ClampedArray% + | ++ `Uint8ClampedArray` + | +
+ The `Uint8ClampedArray` constructor ( |
+
| + %Uint8ClampedArrayPrototype% + | ++ `Uint8ClampedArray.prototype` + | ++ The initial value of the `prototype` data property of %Uint8ClampedArray% + | +
| + %Uint16Array% + | ++ `Uint16Array` + | +
+ The `Uint16Array` constructor ( |
+
| + %Uint16ArrayPrototype% + | ++ `Uint16Array.prototype` + | ++ The initial value of the `prototype` data property of %Uint16Array% + | +
| + %Uint32Array% + | ++ `Uint32Array` + | +
+ The `Uint32Array` constructor ( |
+
| + %Uint32ArrayPrototype% + | ++ `Uint32Array.prototype` + | ++ The initial value of the `prototype` data property of %Uint32Array% + | +
| + %URIError% + | ++ `URIError` + | +
+ The `URIError` constructor ( |
+
| + %URIErrorPrototype% + | ++ `URIError.prototype` + | ++ The initial value of the `prototype` data property of %URIError% + | +
| + %WeakMap% + | ++ `WeakMap` + | +
+ The `WeakMap` constructor ( |
+
| + %WeakMapPrototype% + | ++ `WeakMap.prototype` + | ++ The initial value of the `prototype` data property of %WeakMap% + | +
| + %WeakSet% + | ++ `WeakSet` + | +
+ The `WeakSet` constructor ( |
+
| + %WeakSetPrototype% + | ++ `WeakSet.prototype` + | ++ The initial value of the `prototype` data property of %WeakSet% + | +