6.1.5.1 Well-Known Symbols

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 Code Realms (8.2).

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 Table 1.

6.1.7.1 Property Attributes

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 Table 2.

An accessor property associates a key value with the attributes listed in Table 3.

If the initial values of a property's attributes are not explicitly specified by this specification, the default value defined in Table 4 is used.

6.1.7.2 Object Internal Methods and Internal Slots

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 [[ ]].

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

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

Table 6 summarizes additional essential internal methods that are supported by objects that may be called as functions. A function object is an object that supports the [[Call]] internal methods. A constructor (also referred to as a constructor function) is a function object that supports the [[Construct]] internal method.

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

6.1.7.3 Invariants of the Essential Internal Methods

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.

Definitions:

●   The target of an internal method is the object upon which the internal method is called.

●   A target is non-extensible if it has been observed to return false from its [[IsExtensible]] internal method, or true from its [[PreventExtensions]] internal method.

●   A non-existent property is a property that does not exist as an own property on a non-extensible target.

●   All references to SameValue are according to the definition of SameValue algorithm specified in 7.2.9.

[[GetPrototypeOf]] ( )

●   The Type of the return value must be either Object or Null.

●   If target is non-extensible, and [[GetPrototypeOf]] returns a value v, then any future calls to [[GetPrototypeOf]] should return the SameValue as v.

[[SetPrototypeOf]] (V)

●   The Type of the return value must be Boolean.

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

[[PreventExtensions]] ( )

●   The Type of the return value must be Boolean.

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

[[GetOwnProperty]] (P)

●   The Type of the return value must be either Property Descriptor or Undefined.

●   If the Type of the return value is Property Descriptor, the return value must be a complete property descriptor (see 6.2.4.6).

●   If a property P is described as a data property with Desc.[[Value]] equal to v and Desc.[[Writable]] and Desc.[[Configurable]] are both false, then the SameValue must be returned for the Desc.[[Value]] attribute of the property on all future calls to [[GetOwnProperty]] ( P ).

●   If P's attributes other than [[Writable]] may change over time or if the property might disappear, then P's [[Configurable]] attribute must be true.

●   If the [[Writable]] attribute may change from false to true, then the [[Configurable]] attribute must be true.

●   If the target is non-extensible and P is non-existent, then all future calls to [[GetOwnProperty]] (P) on the target must describe P as non-existent (i.e. [[GetOwnProperty]] (P) must return undefined).

[[DefineOwnProperty]] (P, Desc)

●   The Type of the return value must be Boolean.

●   [[DefineOwnProperty]] must return false if P has previously been observed as a non-configurable own property of the target, unless either:

1. P is a non-configurable writable own data property. A non-configurable writable data property can be changed into a non-configurable non-writable data property.

2. All attributes in Desc are the SameValue as P’s attributes.

●   [[DefineOwnProperty]] (P, Desc) must return false if target is non-extensible and P is a non-existent own property. That is, a non-extensible target object cannot be extended with new properties.

[[HasProperty]] ( P )

●   The Type of the return value must be Boolean.

●   If P was previously observed as a non-configurable data or accessor own property of the target, [[HasProperty]] must return true.

[[Get]] (P, Receiver)

●   If P was previously observed as a non-configurable, non-writable own data property of the target with value v, then [[Get]] must return the SameValue.

●   If P was previously observed as a non-configurable own accessor property of the target whose [[Get]] attribute is undefined, the [[Get]] operation must return undefined.

[[Set]] ( P, V, Receiver)

●   The Type of the return value must be Boolean.

●   If P was previously observed as a non-configurable, non-writable own data property of the target, then [[Set]] must return false unless V is the SameValue as P's [[Value]] attribute.

●   If P was previously observed as a non-configurable own accessor property of the target whose [[Set]] attribute is undefined, the [[Set]] operation must return false.

[[Delete]] ( P )

●   The Type of the return value must be Boolean.

●   If P was previously observed to be a non-configurable own data or accessor property of the target, [[Delete]] must return false.

[[Enumerate]] ( )

●   The Type of the return value must be Object.

[[OwnPropertyKeys]] ( )

●   The return value must be a List.

●   The Type of each element of the returned List is either String or Symbol.

●   The returned List must contain at least the keys of all non-configurable own properties that have previously been observed.

●   If the object is non-extensible, the returned List must contain only the keys of all own properties of the object that are observable using [[GetOwnProperty]].

[[Construct]] ( )

●   The Type of the return value must be Object.

6.1.7.4 Well-Known Intrinsic Objects

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 8.3. The well-known intrinsics are listed in Table 7.

6.2.2.1 NormalCompletion

The abstract operation NormalCompletion with a single argument, such as:

1. Return NormalCompletion(argument).

Is a shorthand that is defined as follows:

1. Return Completion{[[type]]: normal, [[value]]: argument, [[target]]:empty}.

6.2.2.2 Implicit Completion Values

The algorithms of this specification often implicitly return Completion Records whose [[type]] is normal. Unless it is otherwise obvious from the context, an algorithm statement that returns a value that is not a Completion Record, such as:

1. Return "Infinity".

means the same thing as:

1. Return NormalCompletion("Infinity").

However, if the value expression of a “return” statement is a Completion Record construction literal, the resulting Completion Record is returned. If the value expression is a call to an abstract operation, the “return” statement simply returns the Completion Record produced by the abstract operation.

The abstract operation Completion(completionRecord) is used to emphasize that a previously computed Completion Record is being returned. The Completion abstract operation takes a single argument, completionRecord, and performs the following steps:

1. Assert: completionRecord is a Completion Record.
2. Return completionRecord as the Completion Record of this abstract operation.

A “return” statement without a value in an algorithm step means the same thing as:

1. Return NormalCompletion(undefined).

Any reference to a Completion Record value that is in a context that does not explicitly require a complete Completion Record value is equivalent to an explicit reference to the [[value]] field of the Completion Record value unless the Completion Record is an abrupt completion.

6.2.2.3 Throw an Exception

Algorithms steps that say to throw an exception, such as

1. Throw a TypeError exception.

mean the same things as:

1. Return Completion{[[type]]: throw, [[value]]: a newly created TypeError object, [[target]]:empty}.

6.2.2.4 ReturnIfAbrupt

Algorithms steps that say

1. ReturnIfAbrupt(argument).

mean the same thing as:

1. If argument is an abrupt completion, return argument.
2. Else if argument is a Completion Record, let argument be argument.[[value]].

6.2.2.5 UpdateEmpty ( completionRecord, value)

The abstract operation UpdateEmpty with arguments completionRecord and value performs the following steps:

1. Assert: if completionRecord.[[type]] is throw then completionRecord.[[value]] is not empty.
2. If completionRecord.[[type]] is throw, return Completion(completionRecord).
3. If completionRecord.[[value]] is not empty, return Completion(completionRecord).
4. Return Completion{[[type]]: completionRecord.[[type]], [[value]]: value, [[target]]: completionRecord.[[target]] }.

6.2.3.1 GetValue (V)

1. ReturnIfAbrupt(V).
2. If Type(V) is not Reference, return V.
3. Let base be GetBase(V).
4. If IsUnresolvableReference(V), throw a ReferenceError exception.
5. If IsPropertyReference(V), then
   1. If HasPrimitiveBase(V) is true, then
      1. Assert: In this case, base will never be null or undefined.
      2. Let base be ToObject(base).
   2. Return base.[[Get]](GetReferencedName(V), GetThisValue(V)).
6. Else base must be an Environment Record,
   1. Return base.GetBindingValue(GetReferencedName(V), IsStrictReference(V)) (see 8.1.1).

6.2.3.2 PutValue (V, W)

1. ReturnIfAbrupt(V).
2. ReturnIfAbrupt(W).
3. If Type(V) is not Reference, throw a ReferenceError exception.
4. Let base be GetBase(V).
5. If IsUnresolvableReference(V), then
   1. If IsStrictReference(V) is true, then
      1. Throw ReferenceError exception.
   2. Let globalObj be GetGlobalObject().
   3. Return Set(globalObj,GetReferencedName(V), W, false).
6. Else if IsPropertyReference(V), then
   1. If HasPrimitiveBase(V) is true, then
      1. Assert: In this case, base will never be null or undefined.
      2. Set base to ToObject(base).
   2. Let succeeded be base.[[Set]](GetReferencedName(V), W, GetThisValue(V)).
   3. ReturnIfAbrupt(succeeded).
   4. If succeeded is false and IsStrictReference(V) is true, throw a TypeError exception.
   5. Return.
7. Else base must be an Environment Record.
   1. Return base.SetMutableBinding(GetReferencedName(V), W, IsStrictReference(V)) (see 8.1.1).

6.2.3.3 GetThisValue (V)

1. Assert: IsPropertyReference(V) is true.
2. If IsSuperReference(V), then
   1. Return the value of the thisValue component of the reference V.
3. Return GetBase(V).

6.2.3.4 InitializeReferencedBinding (V, W)

1. ReturnIfAbrupt(V).
2. ReturnIfAbrupt(W).
3. Assert: Type(V) is Reference.
4. Assert: IsUnresolvableReference(V) is false.
5. Let base be GetBase(V).
6. Assert: base is an Environment Record.
7. Return base.InitializeBinding(GetReferencedName(V), W).

6.2.4.1 IsAccessorDescriptor ( Desc )

When the abstract operation IsAccessorDescriptor is called with Property Descriptor Desc, the following steps are taken:

1. If Desc is undefined, return false.
2. If both Desc.[[Get]] and Desc.[[Set]] are absent, return false.
3. Return true.

6.2.4.2 IsDataDescriptor ( Desc )

When the abstract operation IsDataDescriptor is called with Property Descriptor Desc, the following steps are taken:

1. If Desc is undefined, return false.
2. If both Desc.[[Value]] and Desc.[[Writable]] are absent, return false.
3. Return true.

6.2.4.3 IsGenericDescriptor ( Desc )

When the abstract operation IsGenericDescriptor is called with Property Descriptor Desc, the following steps are taken:

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

6.2.4.4 FromPropertyDescriptor ( Desc )

When the abstract operation FromPropertyDescriptor is called with Property Descriptor Desc, the following steps are taken:

1. If Desc is undefined, return undefined.
2. Let obj be ObjectCreate(%ObjectPrototype%).
3. Assert: obj is an extensible ordinary object with no own properties.
4. If Desc has a [[Value]] field, then
   1. Perform CreateDataProperty(obj, "value", Desc.[[Value]]).
5. If Desc has a [[Writable]] field, then
   1. Perform CreateDataProperty(obj, "writable", Desc.[[Writable]]).
6. If Desc has a [[Get]] field, then
   1. Perform CreateDataProperty(obj, "get", Desc.[[Get]]).
7. If Desc has a [[Set]] field, then
   1. Perform CreateDataProperty(obj, "set", Desc.[[Set]])
8. If Desc has an [[Enumerable]] field, then
   1. Perform CreateDataProperty(obj, "enumerable", Desc.[[Enumerable]]).
9. If Desc has a [[Configurable]] field, then
   1. Perform CreateDataProperty(obj , "configurable", Desc.[[Configurable]]).
10. Assert: all of the above CreateDataProperty operations return true.
11. Return obj.

6.2.4.5 ToPropertyDescriptor ( Obj )

When the abstract operation ToPropertyDescriptor is called with object Obj, the following steps are taken:

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

6.2.4.6 CompletePropertyDescriptor ( Desc )

When the abstract operation CompletePropertyDescriptor is called with Property Descriptor Desc the following steps are taken:

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

6.2.6.1 CreateByteDataBlock(size)

When the abstract operation CreateByteDataBlock is called with integer argument size, the following steps are taken:

1. Assert: size≥0.
2. Let db be a new Data Block value consisting of size bytes. If it is impossible to create such a Data Block, throw a RangeError exception.
3. Set all of the bytes of db to 0.
4. Return db.

6.2.6.2 CopyDataBlockBytes(toBlock, toIndex, fromBlock, fromIndex, count)

When the abstract operation CopyDataBlockBytes is called the following steps are taken:

1. Assert: fromBlock and toBlock are distinct Data Block values.
2. Assert: fromIndex, toIndex, and count are positive integer values.
3. Let fromSize be the number of bytes in fromBlock.
4. Assert: fromIndex+count ≤ fromSize.
5. Let toSize be the number of bytes in toBlock.
6. Assert: toIndex+count ≤ toSize.
7. Repeat, while count>0
   1. Set toBlock[toIndex] to the value of fromBlock[fromIndex].
   2. Increment toIndex and fromIndex each by 1.
   3. Decrement count by 1.
8. Return NormalCompletion(empty)