When the [[GetPrototypeOf]] internal method of O is called, the following steps are taken:

1. Return ! OrdinaryGetPrototypeOf(O).

When the [[SetPrototypeOf]] internal method of O is called with argument V, the following steps are taken:

1. Return ! OrdinarySetPrototypeOf(O, V).

When the [[IsExtensible]] internal method of O is called, the following steps are taken:

1. Return ! OrdinaryIsExtensible(O).

When the [[PreventExtensions]] internal method of O is called, the following steps are taken:

1. Return ! OrdinaryPreventExtensions(O).

When the [[GetOwnProperty]] internal method of O is called with property key P, the following steps are taken:

1. Return ! OrdinaryGetOwnProperty(O, P).

When the [[DefineOwnProperty]] internal method of O is called with property key P and Property Descriptor Desc, the following steps are taken:

1. Return ? OrdinaryDefineOwnProperty(O, P, Desc).

When the [[HasProperty]] internal method of O is called with property key P, the following steps are taken:

1. Return ? OrdinaryHasProperty(O, P).

When the [[Get]] internal method of O is called with property key P and ECMAScript language value Receiver, the following steps are taken:

1. Return ? OrdinaryGet(O, P, Receiver).

When the [[Set]] internal method of O is called with property key P, value V, and ECMAScript language value Receiver, the following steps are taken:

1. Return ? OrdinarySet(O, P, V, Receiver).

When the [[Delete]] internal method of O is called with property key P, the following steps are taken:

1. Return ? OrdinaryDelete(O, P).

When the [[OwnPropertyKeys]] internal method of O is called, the following steps are taken:

1. Return ! OrdinaryOwnPropertyKeys(O).

The abstract operation OrdinaryObjectCreate with argument proto (an object or null) is used to specify the runtime creation of new ordinary objects. The optional argument additionalInternalSlotsList is a List of the names of additional internal slots that must be defined as part of the object, beyond [[Prototype]] and [[Extensible]]. If the list is not provided, a new empty List is used. This abstract operation performs the following steps:

1. Let internalSlotsList be « [[Prototype]], [[Extensible]] ».
2. If additionalInternalSlotsList is present, append each of its elements to internalSlotsList.
3. Let O be ! MakeBasicObject(internalSlotsList).
4. Set O.[[Prototype]] to proto.
5. Return O.

Note

Although OrdinaryObjectCreate does little more than call MakeBasicObject, its use communicates the intention to create an ordinary object, and not an exotic one. Thus, within this specification, it is not called by any algorithm that subsequently modifies the internal methods of the object in ways that would make the result non-ordinary. Operations that create exotic objects invoke MakeBasicObject directly.

The abstract operation OrdinaryCreateFromConstructor 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]]. The optional internalSlotsList is a List of the names of additional internal slots that must be defined as part of the object. If the list is not provided, a new empty List is used. This abstract operation performs the following steps:

1. Assert: intrinsicDefaultProto is a String value that is this specification's name of an intrinsic object. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.
2. Let proto be ? GetPrototypeFromConstructor(constructor, intrinsicDefaultProto).
3. Return OrdinaryObjectCreate(proto, internalSlotsList).

The abstract operation GetPrototypeFromConstructor 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]]. This abstract operation performs the following steps:

1. Assert: intrinsicDefaultProto is a String value that is this specification's name of an intrinsic object. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.
2. Assert: IsCallable(constructor) is true.
3. Let proto be ? Get(constructor, "prototype").
4. If Type(proto) is not Object, then
   1. Let realm be ? GetFunctionRealm(constructor).
   2. Set proto to realm's intrinsic object named intrinsicDefaultProto.
5. Return proto.

Note

If constructor does not supply a [[Prototype]] value, the default value that is used is obtained from the realm of the constructor function rather than from the running execution context.

The abstract operation RequireInternalSlot throws an exception unless O is an Object and has the given internal slot.

1. If Type(O) is not Object, throw a TypeError exception.
2. If O does not have an internalSlot internal slot, throw a TypeError exception.

The [[Call]] internal method for an ECMAScript function object F is called with parameters thisArgument and argumentsList, a List of ECMAScript language values. The following steps are taken:

1. Assert: F is an ECMAScript function object.
2. If F.[[IsClassConstructor]] is true, throw a TypeError exception.
3. Let callerContext be the running execution context.
4. Let calleeContext be PrepareForOrdinaryCall(F, undefined).
5. Assert: calleeContext is now the running execution context.
6. Perform OrdinaryCallBindThis(F, calleeContext, thisArgument).
7. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
8. Remove calleeContext from the execution context stack and restore callerContext as the running execution context.
9. If result.[[Type]] is return, return NormalCompletion(result.[[Value]]).
10. ReturnIfAbrupt(result).
11. Return NormalCompletion(undefined).

Note

When calleeContext is removed from the execution context stack in step 8 it must not be destroyed if it is suspended and retained for later resumption by an accessible generator object.

The [[Construct]] internal method for an ECMAScript function object F is called with parameters argumentsList and newTarget. argumentsList is a possibly empty List of ECMAScript language values. The following steps are taken:

1. Assert: F is an ECMAScript function object.
2. Assert: Type(newTarget) is Object.
3. Let callerContext be the running execution context.
4. Let kind be F.[[ConstructorKind]].
5. If kind is base, then
   1. Let thisArgument be ? OrdinaryCreateFromConstructor(newTarget, "%Object.prototype%").
6. Let calleeContext be PrepareForOrdinaryCall(F, newTarget).
7. Assert: calleeContext is now the running execution context.
8. If kind is base, perform OrdinaryCallBindThis(F, calleeContext, thisArgument).
9. Let constructorEnv be the LexicalEnvironment of calleeContext.
10. Let envRec be constructorEnv's EnvironmentRecord.
11. Let result be OrdinaryCallEvaluateBody(F, argumentsList).
12. Remove calleeContext from the execution context stack and restore callerContext as the running execution context.
13. If result.[[Type]] is return, then
    1. If Type(result.[[Value]]) is Object, return NormalCompletion(result.[[Value]]).
    2. If kind is base, return NormalCompletion(thisArgument).
    3. If result.[[Value]] is not undefined, throw a TypeError exception.
14. Else, ReturnIfAbrupt(result).
15. Return ? envRec.GetThisBinding().

The abstract operation OrdinaryFunctionCreate requires the arguments: an object functionPrototype, a parameter list Parse Node specified by ParameterList, a body Parse Node specified by Body, thisMode which is either lexical-this or non-lexical-this, and a Lexical Environment specified by Scope. OrdinaryFunctionCreate performs the following steps:

1. Assert: Type(functionPrototype) is Object.
2. Let internalSlotsList be the internal slots listed in Table 27.
3. Let F be ! OrdinaryObjectCreate(functionPrototype, internalSlotsList).
4. Set F.[[Call]] to the definition specified in 9.2.1.
5. Set F.[[FormalParameters]] to ParameterList.
6. Set F.[[ECMAScriptCode]] to Body.
7. If the source text matching Body is strict mode code, let Strict be true; else let Strict be false.
8. Set F.[[Strict]] to Strict.
9. If thisMode is lexical-this, set F.[[ThisMode]] to lexical.
10. Else if Strict is true, set F.[[ThisMode]] to strict.
11. Else, set F.[[ThisMode]] to global.
12. Set F.[[IsClassConstructor]] to false.
13. Set F.[[Environment]] to Scope.
14. Set F.[[ScriptOrModule]] to GetActiveScriptOrModule().
15. Set F.[[Realm]] to the current Realm Record.
16. Set F.[[HomeObject]] to undefined.
17. Let len be the ExpectedArgumentCount of ParameterList.
18. Perform ! SetFunctionLength(F, len).
19. Return F.

The abstract operation AddRestrictedFunctionProperties is called with a function object F and Realm Record realm as its argument. It performs the following steps:

1. Assert: realm.[[Intrinsics]].[[%ThrowTypeError%]] exists and has been initialized.
2. Let thrower be realm.[[Intrinsics]].[[%ThrowTypeError%]].
3. Perform ! DefinePropertyOrThrow(F, "caller", PropertyDescriptor { [[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: true }).
4. Return ! DefinePropertyOrThrow(F, "arguments", PropertyDescriptor { [[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: true }).

The abstract operation MakeConstructor requires a Function argument F and optionally, a Boolean writablePrototype and an object prototype. If prototype is provided it is assumed to already contain, if needed, a "constructor" property whose value is F. This operation converts F into a constructor by performing the following steps:

1. Assert: F is an ECMAScript function object.
2. Assert: IsConstructor(F) is false.
3. Assert: F is an extensible object that does not have a "prototype" own property.
4. Set F.[[Construct]] to the definition specified in 9.2.2.
5. Set F.[[ConstructorKind]] to base.
6. If writablePrototype is not present, set writablePrototype to true.
7. If prototype is not present, then
   1. Set prototype to OrdinaryObjectCreate(%Object.prototype%).
   2. Perform ! DefinePropertyOrThrow(prototype, "constructor", PropertyDescriptor { [[Value]]: F, [[Writable]]: writablePrototype, [[Enumerable]]: false, [[Configurable]]: true }).
8. Perform ! DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: writablePrototype, [[Enumerable]]: false, [[Configurable]]: false }).
9. Return NormalCompletion(undefined).

The abstract operation MakeClassConstructor with argument F performs the following steps:

1. Assert: F is an ECMAScript function object.
2. Assert: F.[[IsClassConstructor]] is false.
3. Set F.[[IsClassConstructor]] to true.
4. Return NormalCompletion(undefined).

The abstract operation MakeMethod with arguments F and homeObject configures F as a method by performing the following steps:

1. Assert: F is an ECMAScript function object.
2. Assert: Type(homeObject) is Object.
3. Set F.[[HomeObject]] to homeObject.
4. Return NormalCompletion(undefined).

The abstract operation SetFunctionName requires a Function argument F, a String or Symbol argument name and optionally a String argument prefix. This operation adds a "name" property to F by performing the following steps:

1. Assert: F is an extensible object that does not have a "name" own property.
2. Assert: Type(name) is either Symbol or String.
3. Assert: If prefix is present, then Type(prefix) is String.
4. If Type(name) is Symbol, then
   1. Let description be name's [[Description]] value.
   2. If description is undefined, set name to the empty String.
   3. Else, set name to the string-concatenation of "[", description, and "]".
5. If prefix is present, then
   1. Set name to the string-concatenation of prefix, the code unit 0x0020 (SPACE), and name.
6. Return ! DefinePropertyOrThrow(F, "name", PropertyDescriptor { [[Value]]: name, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }).

The abstract operation SetFunctionLength requires a Function argument F and a Number argument length. This operation adds a "length" property to F by performing the following steps:

1. Assert: F is an extensible object that does not have a "length" own property.
2. Assert: Type(length) is Number.
3. Assert: ! IsNonNegativeInteger(length) is true.
4. Return ! DefinePropertyOrThrow(F, "length", PropertyDescriptor { [[Value]]: length, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }).

Note 1

When an execution context is established for evaluating an ECMAScript function a new function Environment Record is created and bindings for each formal parameter are instantiated in that Environment Record. Each declaration in the function body is also instantiated. If the function's formal parameters do not include any default value initializers then the body declarations are instantiated in the same Environment Record as the parameters. If default value parameter initializers exist, a second Environment Record is created for the body declarations. Formal parameters and functions are initialized as part of FunctionDeclarationInstantiation. All other bindings are initialized during evaluation of the function body.

FunctionDeclarationInstantiation is performed as follows using arguments func and argumentsList. func is the function object for which the execution context is being established.

1. Let calleeContext be the running execution context.
2. Let code be func.[[ECMAScriptCode]].
3. Let strict be func.[[Strict]].
4. Let formals be func.[[FormalParameters]].
5. Let parameterNames be the BoundNames of formals.
6. If parameterNames has any duplicate entries, let hasDuplicates be true. Otherwise, let hasDuplicates be false.
7. Let simpleParameterList be IsSimpleParameterList of formals.
8. Let hasParameterExpressions be ContainsExpression of formals.
9. Let varNames be the VarDeclaredNames of code.
10. Let varDeclarations be the VarScopedDeclarations of code.
11. Let lexicalNames be the LexicallyDeclaredNames of code.
12. Let functionNames be a new empty List.
13. Let functionsToInitialize be a new empty List.
14. For each d in varDeclarations, in reverse list order, do
    1. If d is neither a VariableDeclaration nor a ForBinding nor a BindingIdentifier, then
       1. Assert: d is either a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration.
       2. Let fn be the sole element of the BoundNames of d.
       3. If fn is not an element of functionNames, then
          1. Insert fn as the first element of functionNames.
          2. NOTE: If there are multiple function declarations for the same name, the last declaration is used.
          3. Insert d as the first element of functionsToInitialize.
15. Let argumentsObjectNeeded be true.
16. If func.[[ThisMode]] is lexical, then
    1. NOTE: Arrow functions never have an arguments objects.
    2. Set argumentsObjectNeeded to false.
17. Else if "arguments" is an element of parameterNames, then
    1. Set argumentsObjectNeeded to false.
18. Else if hasParameterExpressions is false, then
    1. If "arguments" is an element of functionNames or if "arguments" is an element of lexicalNames, then
       1. Set argumentsObjectNeeded to false.
19. If strict is true or if hasParameterExpressions is false, then
    1. NOTE: Only a single lexical environment is needed for the parameters and top-level vars.
    2. Let env be the LexicalEnvironment of calleeContext.
    3. Let envRec be env's EnvironmentRecord.
20. Else,
    1. NOTE: A separate Environment Record is needed to ensure that bindings created by direct eval calls in the formal parameter list are outside the environment where parameters are declared.
    2. Let calleeEnv be the LexicalEnvironment of calleeContext.
    3. Let env be NewDeclarativeEnvironment(calleeEnv).
    4. Let envRec be env's EnvironmentRecord.
    5. Assert: The VariableEnvironment of calleeContext is calleeEnv.
    6. Set the LexicalEnvironment of calleeContext to env.
21. For each String paramName in parameterNames, do
    1. Let alreadyDeclared be envRec.HasBinding(paramName).
    2. NOTE: Early errors ensure that duplicate parameter names can only occur in non-strict functions that do not have parameter default values or rest parameters.
    3. If alreadyDeclared is false, then
       1. Perform ! envRec.CreateMutableBinding(paramName, false).
       2. If hasDuplicates is true, then
          1. Perform ! envRec.InitializeBinding(paramName, undefined).
22. If argumentsObjectNeeded is true, then
    1. If strict is true or if simpleParameterList is false, then
       1. Let ao be CreateUnmappedArgumentsObject(argumentsList).
    2. Else,
       1. NOTE: A mapped argument object is only provided for non-strict functions that don't have a rest parameter, any parameter default value initializers, or any destructured parameters.
       2. Let ao be CreateMappedArgumentsObject(func, formals, argumentsList, envRec).
    3. If strict is true, then
       1. Perform ! envRec.CreateImmutableBinding("arguments", false).
    4. Else,
       1. Perform ! envRec.CreateMutableBinding("arguments", false).
    5. Call envRec.InitializeBinding("arguments", ao).
    6. Let parameterBindings be a new List of parameterNames with "arguments" appended.
23. Else,
    1. Let parameterBindings be parameterNames.
24. Let iteratorRecord be CreateListIteratorRecord(argumentsList).
25. If hasDuplicates is true, then
    1. Perform ? IteratorBindingInitialization for formals with iteratorRecord and undefined as arguments.
26. Else,
    1. Perform ? IteratorBindingInitialization for formals with iteratorRecord and env as arguments.
27. If hasParameterExpressions is false, then
    1. NOTE: Only a single lexical environment is needed for the parameters and top-level vars.
    2. Let instantiatedVarNames be a copy of the List parameterBindings.
    3. For each n in varNames, do
       1. If n is not an element of instantiatedVarNames, then
          1. Append n to instantiatedVarNames.
          2. Perform ! envRec.CreateMutableBinding(n, false).
          3. Call envRec.InitializeBinding(n, undefined).
    4. Let varEnv be env.
    5. Let varEnvRec be envRec.
28. Else,
    1. NOTE: A separate Environment Record is needed to ensure that closures created by expressions in the formal parameter list do not have visibility of declarations in the function body.
    2. Let varEnv be NewDeclarativeEnvironment(env).
    3. Let varEnvRec be varEnv's EnvironmentRecord.
    4. Set the VariableEnvironment of calleeContext to varEnv.
    5. Let instantiatedVarNames be a new empty List.
    6. For each n in varNames, do
       1. If n is not an element of instantiatedVarNames, then
          1. Append n to instantiatedVarNames.
          2. Perform ! varEnvRec.CreateMutableBinding(n, false).
          3. If n is not an element of parameterBindings or if n is an element of functionNames, let initialValue be undefined.
          4. Else,
             1. Let initialValue be ! envRec.GetBindingValue(n, false).
          5. Call varEnvRec.InitializeBinding(n, initialValue).
          6. NOTE: A var with the same name as a formal parameter initially has the same value as the corresponding initialized parameter.
29. NOTE: Annex B.3.3.1 adds additional steps at this point.
30. If strict is false, then
    1. Let lexEnv be NewDeclarativeEnvironment(varEnv).
    2. NOTE: Non-strict functions use a separate lexical Environment Record for top-level lexical declarations so that a direct eval can determine whether any var scoped declarations introduced by the eval code conflict with pre-existing top-level lexically scoped declarations. This is not needed for strict functions because a strict direct eval always places all declarations into a new Environment Record.
31. Else, let lexEnv be varEnv.
32. Let lexEnvRec be lexEnv's EnvironmentRecord.
33. Set the LexicalEnvironment of calleeContext to lexEnv.
34. Let lexDeclarations be the LexicallyScopedDeclarations of code.
35. For each element d in lexDeclarations, do
    1. NOTE: A lexically declared name cannot be the same as a function/generator declaration, formal parameter, or a var name. Lexically declared names are only instantiated here but not initialized.
    2. For each element dn of the BoundNames of d, do
       1. If IsConstantDeclaration of d is true, then
          1. Perform ! lexEnvRec.CreateImmutableBinding(dn, true).
       2. Else,
          1. Perform ! lexEnvRec.CreateMutableBinding(dn, false).
36. For each Parse Node f in functionsToInitialize, do
    1. Let fn be the sole element of the BoundNames of f.
    2. Let fo be InstantiateFunctionObject of f with argument lexEnv.
    3. Perform ! varEnvRec.SetMutableBinding(fn, fo, false).
37. Return NormalCompletion(empty).

Note 2

B.3.3 provides an extension to the above algorithm that is necessary for backwards compatibility with web browser implementations of ECMAScript that predate ECMAScript 2015.

Note 3

Parameter Initializers may contain direct eval expressions. Any top level declarations of such evals are only visible to the eval code (10.2). The creation of the environment for such declarations is described in 14.1.22.

The [[Call]] internal method for a built-in function object F is called with parameters thisArgument and argumentsList, a List of ECMAScript language values. The following steps are taken:

1. Let callerContext be the running execution context.
2. If callerContext is not already suspended, suspend callerContext.
3. Let calleeContext be a new execution context.
4. Set the Function of calleeContext to F.
5. Let calleeRealm be F.[[Realm]].
6. Set the Realm of calleeContext to calleeRealm.
7. Set the ScriptOrModule of calleeContext to F.[[ScriptOrModule]].
8. Perform any necessary implementation-defined initialization of calleeContext.
9. Push calleeContext onto the execution context stack; calleeContext is now the running execution context.
10. Let result be the Completion Record that is the result of evaluating F in a manner that conforms to the specification of F. thisArgument is the this value, argumentsList provides the named parameters, and the NewTarget value is undefined.
11. Remove calleeContext from the execution context stack and restore callerContext as the running execution context.
12. Return result.

Note

When calleeContext is removed from the execution context stack it must not be destroyed if it has been suspended and retained by an accessible generator object for later resumption.

The [[Construct]] internal method for built-in function object F is called with parameters argumentsList and newTarget. The steps performed are the same as [[Call]] (see 9.3.1) except that step 10 is replaced by:

10. Let result be the Completion Record that is the result of evaluating F in a manner that conforms to the specification of F. The this value is uninitialized, argumentsList provides the named parameters, and newTarget provides the NewTarget value.

The abstract operation CreateBuiltinFunction takes arguments steps, internalSlotsList, realm, and prototype. The argument internalSlotsList is a List of the names of additional internal slots that must be defined as part of the object. CreateBuiltinFunction returns a built-in function object created by the following steps:

1. Assert: steps is either a set of algorithm steps or other definition of a function's behaviour provided in this specification.
2. If realm is not present, set realm to the current Realm Record.
3. Assert: realm is a Realm Record.
4. If prototype is not present, set prototype to realm.[[Intrinsics]].[[%Function.prototype%]].
5. Let func be a new built-in function object that when called performs the action described by steps. The new function object has internal slots whose names are the elements of internalSlotsList.
6. Set func.[[Realm]] to realm.
7. Set func.[[Prototype]] to prototype.
8. Set func.[[Extensible]] to true.
9. Set func.[[ScriptOrModule]] to null.
10. Return func.

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

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 9.1. These methods are installed in BoundFunctionCreate.

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

Internal Slot	Type	Description
[[BoundTargetFunction]]	Callable Object	The wrapped function object.
[[BoundThis]]	Any	The value that is always passed as the this value when calling the wrapped function.
[[BoundArguments]]	List of Any	A list of values whose elements are used as the first arguments to any call to the wrapped function.

An Array object is an exotic object that gives special treatment to array index property keys (see 6.1.7). A property whose property name is an array index is also called an element. Every Array object has a non-configurable "length" property whose value is always a nonnegative integer 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 object 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 object and is unaffected by "length" or array index properties that may be inherited from its prototypes.

Note

A String property name P is an array index if and only if ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal to 2³² - 1.

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

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 number of code unit elements in 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 9.1. These methods are installed in StringCreate.

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

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 9.1. These methods are installed in CreateMappedArgumentsObject.

Note 1

While CreateUnmappedArgumentsObject is grouped into this clause, it creates an ordinary object, not an arguments exotic object.

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 (19.1.3.6) to identify them as such.

Note 2

The integer-indexed data properties of an arguments exotic object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. If the arguments object is an ordinary object, the values of its properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.

Note 3

The ParameterMap object and its property values are used as a device for specifying the arguments object correspondence to argument bindings. The ParameterMap object and the objects that are the values of its properties are not directly observable from ECMAScript code. An ECMAScript implementation does not need to actually create or use such objects to implement the specified semantics.

Note 4

Ordinary arguments objects define a non-configurable accessor property named "callee" which throws a TypeError exception on access. The "callee" property has a more specific meaning for arguments exotic objects, which are created only for some class of non-strict functions. The definition of this property in the ordinary variant exists to ensure that it is not defined in any other manner by conforming ECMAScript implementations.

Note 5

ECMAScript implementations of arguments exotic objects have historically contained an accessor property named "caller". Prior to ECMAScript 2017, this specification included the definition of a throwing "caller" property on ordinary arguments objects. Since implementations do not contain this extension any longer, ECMAScript 2017 dropped the requirement for a throwing "caller" accessor.

An Integer-Indexed exotic object is an exotic object that performs special handling of integer index property keys.

Integer-Indexed exotic objects have the same internal slots as ordinary objects and additionally [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], [[ContentType]], and [[TypedArrayName]] internal slots.

An object is an Integer-Indexed exotic object if its [[GetOwnProperty]], [[HasProperty]], [[DefineOwnProperty]], [[Get]], [[Set]], and [[OwnPropertyKeys]] internal methods use the definitions in this section, and its other essential internal methods use the definitions found in 9.1. These methods are installed by IntegerIndexedObjectCreate.

A module namespace exotic object is an exotic object that exposes the bindings exported from an ECMAScript Module (See 15.2.3). 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 [[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 9.1. These methods are installed by ModuleNamespaceCreate.

Module namespace exotic objects have the internal slots defined in Table 29.

Internal Slot	Type	Description
[[Module]]	Module Record	The Module Record whose exports this namespace exposes.
[[Exports]]	List of String	A List containing the String values of the exported names exposed as own properties of this object. The list is ordered as if an Array of those String values had been sorted using Array.prototype.sort using undefined as comparefn.
[[Prototype]]	Null	This slot always contains the value null (see 9.4.6.1).

Module namespace exotic objects provide alternative definitions for all of the internal methods except [[GetPrototypeOf]], which behaves as defined in 9.1.1.

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

Note

Unlike other exotic objects, there is not a dedicated creation abstract operation provided for immutable prototype exotic objects. This is because they are only used by %ObjectPrototype% and by host environments, and in host environments, the relevant objects are potentially exotic in other ways and thus need their own dedicated creation operation.

When the [[GetPrototypeOf]] internal method of a Proxy exotic object O is called, the following steps are taken:

1. Let handler be O.[[ProxyHandler]].
2. If handler is null, throw a TypeError exception.
3. Assert: Type(handler) is Object.
4. Let target be O.[[ProxyTarget]].
5. Let trap be ? GetMethod(handler, "getPrototypeOf").
6. If trap is undefined, then
   1. Return ? target.[[GetPrototypeOf]]().
7. Let handlerProto be ? Call(trap, handler, « target »).
8. If Type(handlerProto) is neither Object nor Null, throw a TypeError exception.
9. Let extensibleTarget be ? IsExtensible(target).
10. If extensibleTarget is true, return handlerProto.
11. Let targetProto be ? target.[[GetPrototypeOf]]().
12. If SameValue(handlerProto, targetProto) is false, throw a TypeError exception.
13. Return handlerProto.

Note

[[GetPrototypeOf]] for proxy objects enforces the following invariants:

• The result of [[GetPrototypeOf]] must be either an Object or null.
• If the target object is not extensible, [[GetPrototypeOf]] applied to the proxy object must return the same value as [[GetPrototypeOf]] applied to the proxy object's target object.

When the [[SetPrototypeOf]] internal method of a Proxy exotic object O is called with argument V, the following steps are taken:

1. Assert: Either Type(V) is Object or Type(V) is Null.
2. Let handler be O.[[ProxyHandler]].
3. If handler is null, throw a TypeError exception.
4. Assert: Type(handler) is Object.
5. Let target be O.[[ProxyTarget]].
6. Let trap be ? GetMethod(handler, "setPrototypeOf").
7. If trap is undefined, then
   1. Return ? target.[[SetPrototypeOf]](V).
8. Let booleanTrapResult be ! ToBoolean(? Call(trap, handler, « target, V »)).
9. If booleanTrapResult is false, return false.
10. Let extensibleTarget be ? IsExtensible(target).
11. If extensibleTarget is true, return true.
12. Let targetProto be ? target.[[GetPrototypeOf]]().
13. If SameValue(V, targetProto) is false, throw a TypeError exception.
14. Return true.

Note

[[SetPrototypeOf]] for proxy objects enforces the following invariants:

• The result of [[SetPrototypeOf]] is a Boolean value.
• If the target object is not extensible, the argument value must be the same as the result of [[GetPrototypeOf]] applied to target object.

When the [[IsExtensible]] internal method of a Proxy exotic object O is called, the following steps are taken:

1. Let handler be O.[[ProxyHandler]].
2. If handler is null, throw a TypeError exception.
3. Assert: Type(handler) is Object.
4. Let target be O.[[ProxyTarget]].
5. Let trap be ? GetMethod(handler, "isExtensible").
6. If trap is undefined, then
   1. Return ? IsExtensible(target).
7. Let booleanTrapResult be ! ToBoolean(? Call(trap, handler, « target »)).
8. Let targetResult be ? IsExtensible(target).
9. If SameValue(booleanTrapResult, targetResult) is false, throw a TypeError exception.
10. Return booleanTrapResult.

Note

[[IsExtensible]] for proxy objects enforces the following invariants:

• The result of [[IsExtensible]] is a Boolean value.
• [[IsExtensible]] applied to the proxy object must return the same value as [[IsExtensible]] applied to the proxy object's target object with the same argument.

When the [[PreventExtensions]] internal method of a Proxy exotic object O is called, the following steps are taken:

1. Let handler be O.[[ProxyHandler]].
2. If handler is null, throw a TypeError exception.
3. Assert: Type(handler) is Object.
4. Let target be O.[[ProxyTarget]].
5. Let trap be ? GetMethod(handler, "preventExtensions").
6. If trap is undefined, then
   1. Return ? target.[[PreventExtensions]]().
7. Let booleanTrapResult be ! ToBoolean(? Call(trap, handler, « target »)).
8. If booleanTrapResult is true, then
   1. Let extensibleTarget be ? IsExtensible(target).
   2. If extensibleTarget is true, throw a TypeError exception.
9. Return booleanTrapResult.

Note

[[PreventExtensions]] for proxy objects enforces the following invariants:

• The result of [[PreventExtensions]] is a Boolean value.
• [[PreventExtensions]] applied to the proxy object only returns true if [[IsExtensible]] applied to the proxy object's target object is false.

When the [[GetOwnProperty]] internal method of a Proxy exotic object O is called with property key P, the following steps are taken:

1. Assert: IsPropertyKey(P) is true.
2. Let handler be O.[[ProxyHandler]].
3. If handler is null, throw a TypeError exception.
4. Assert: Type(handler) is Object.
5. Let target be O.[[ProxyTarget]].
6. Let trap be ? GetMethod(handler, "getOwnPropertyDescriptor").
7. If trap is undefined, then
   1. Return ? target.[[GetOwnProperty]](P).
8. Let trapResultObj be ? Call(trap, handler, « target, P »).
9. If Type(trapResultObj) is neither Object nor Undefined, throw a TypeError exception.
10. Let targetDesc be ? target.[[GetOwnProperty]](P).
11. If trapResultObj is undefined, then
    1. If targetDesc is undefined, return undefined.
    2. If targetDesc.[[Configurable]] is false, throw a TypeError exception.
    3. Let extensibleTarget be ? IsExtensible(target).
    4. If extensibleTarget is false, throw a TypeError exception.
    5. Return undefined.
12. Let extensibleTarget be ? IsExtensible(target).
13. Let resultDesc be ? ToPropertyDescriptor(trapResultObj).
14. Call CompletePropertyDescriptor(resultDesc).
15. Let valid be IsCompatiblePropertyDescriptor(extensibleTarget, resultDesc, targetDesc).
16. If valid is false, throw a TypeError exception.
17. If resultDesc.[[Configurable]] is false, then
    1. If targetDesc is undefined or targetDesc.[[Configurable]] is true, then
       1. Throw a TypeError exception.
    2. If resultDesc has a [[Writable]] field and resultDesc.[[Writable]] is false, then
       1. If targetDesc.[[Writable]] is true, throw a TypeError exception.
18. Return resultDesc.

Note

[[GetOwnProperty]] for proxy objects enforces the following invariants:

• The result of [[GetOwnProperty]] must be either an Object or undefined.
• A property cannot be reported as non-existent, if it exists as a non-configurable own property of the target object.
• A property cannot be reported as non-existent, if the target object is not extensible, unless it does not exist as an own property of the target object.
• A property cannot be reported as existent, if the target object is not extensible, unless it exists as an own property of the target object.
• A property cannot be reported as non-configurable, unless it exists as a non-configurable own property of the target object.
• A property cannot be reported as both non-configurable and non-writable, unless it exists as a non-configurable, non-writable own property of the target object.

When the [[DefineOwnProperty]] internal method of a Proxy exotic object O is called with property key P and Property Descriptor Desc, the following steps are taken:

1. Assert: IsPropertyKey(P) is true.
2. Let handler be O.[[ProxyHandler]].
3. If handler is null, throw a TypeError exception.
4. Assert: Type(handler) is Object.
5. Let target be O.[[ProxyTarget]].
6. Let trap be ? GetMethod(handler, "defineProperty").
7. If trap is undefined, then
   1. Return ? target.[[DefineOwnProperty]](P, Desc).
8. Let descObj be FromPropertyDescriptor(Desc).
9. Let booleanTrapResult be ! ToBoolean(? Call(trap, handler, « target, P, descObj »)).
10. If booleanTrapResult is false, return false.
11. Let targetDesc be ? target.[[GetOwnProperty]](P).
12. Let extensibleTarget be ? IsExtensible(target).
13. If Desc has a [[Configurable]] field and if Desc.[[Configurable]] is false, then
    1. Let settingConfigFalse be true.
14. Else, let settingConfigFalse be false.
15. If targetDesc is undefined, then
    1. If extensibleTarget is false, throw a TypeError exception.
    2. If settingConfigFalse is true, throw a TypeError exception.
16. Else,
    1. If IsCompatiblePropertyDescriptor(extensibleTarget, Desc, targetDesc) is false, throw a TypeError exception.
    2. If settingConfigFalse is true and targetDesc.[[Configurable]] is true, throw a TypeError exception.
    3. If IsDataDescriptor(targetDesc) is true, targetDesc.[[Configurable]] is false, and targetDesc.[[Writable]] is true, then
       1. If Desc has a [[Writable]] field and Desc.[[Writable]] is false, throw a TypeError exception.
17. Return true.

Note

[[DefineOwnProperty]] for proxy objects enforces the following invariants:

• The result of [[DefineOwnProperty]] is a Boolean value.
• A property cannot be added, if the target object is not extensible.
• A property cannot be non-configurable, unless there exists a corresponding non-configurable own property of the target object.
• A non-configurable property cannot be non-writable, unless there exists a corresponding non-configurable, non-writable own property of the target object.
• If a property has a corresponding target object property then applying the Property Descriptor of the property to the target object using [[DefineOwnProperty]] will not throw an exception.

When the [[HasProperty]] internal method of a Proxy exotic object O is called with property key P, the following steps are taken:

1. Assert: IsPropertyKey(P) is true.
2. Let handler be O.[[ProxyHandler]].
3. If handler is null, throw a TypeError exception.
4. Assert: Type(handler) is Object.
5. Let target be O.[[ProxyTarget]].
6. Let trap be ? GetMethod(handler, "has").
7. If trap is undefined, then
   1. Return ? target.[[HasProperty]](P).
8. Let booleanTrapResult be ! ToBoolean(? Call(trap, handler, « target, P »)).
9. If booleanTrapResult is false, then
   1. Let targetDesc be ? target.[[GetOwnProperty]](P).
   2. If targetDesc is not undefined, then
      1. If targetDesc.[[Configurable]] is false, throw a TypeError exception.
      2. Let extensibleTarget be ? IsExtensible(target).
      3. If extensibleTarget is false, throw a TypeError exception.
10. Return booleanTrapResult.

Note

[[HasProperty]] for proxy objects enforces the following invariants:

• The result of [[HasProperty]] is a Boolean value.
• A property cannot be reported as non-existent, if it exists as a non-configurable own property of the target object.
• A property cannot be reported as non-existent, if it exists as an own property of the target object and the target object is not extensible.

When the [[Get]] internal method of a Proxy exotic object O is called with property key P and ECMAScript language value Receiver, the following steps are taken:

1. Assert: IsPropertyKey(P) is true.
2. Let handler be O.[[ProxyHandler]].
3. If handler is null, throw a TypeError exception.
4. Assert: Type(handler) is Object.
5. Let target be O.[[ProxyTarget]].
6. Let trap be ? GetMethod(handler, "get").
7. If trap is undefined, then
   1. Return ? target.[[Get]](P, Receiver).
8. Let trapResult be ? Call(trap, handler, « target, P, Receiver »).
9. Let targetDesc be ? target.[[GetOwnProperty]](P).
10. If targetDesc is not undefined and targetDesc.[[Configurable]] is false, then
    1. If IsDataDescriptor(targetDesc) is true and targetDesc.[[Writable]] is false, then
       1. If SameValue(trapResult, targetDesc.[[Value]]) is false, throw a TypeError exception.
    2. If IsAccessorDescriptor(targetDesc) is true and targetDesc.[[Get]] is undefined, then
       1. If trapResult is not undefined, throw a TypeError exception.
11. Return trapResult.

Note

[[Get]] for proxy objects enforces the following invariants:

• The value reported for a property must be the same as the value of the corresponding target object property if the target object property is a non-writable, non-configurable own data property.
• The value reported for a property must be undefined if the corresponding target object property is a non-configurable own accessor property that has undefined as its [[Get]] attribute.

When the [[Set]] internal method of a Proxy exotic object O is called with property key P, value V, and ECMAScript language value Receiver, the following steps are taken:

1. Assert: IsPropertyKey(P) is true.
2. Let handler be O.[[ProxyHandler]].
3. If handler is null, throw a TypeError exception.
4. Assert: Type(handler) is Object.
5. Let target be O.[[ProxyTarget]].
6. Let trap be ? GetMethod(handler, "set").
7. If trap is undefined, then
   1. Return ? target.[[Set]](P, V, Receiver).
8. Let booleanTrapResult be ! ToBoolean(? Call(trap, handler, « target, P, V, Receiver »)).
9. If booleanTrapResult is false, return false.
10. Let targetDesc be ? target.[[GetOwnProperty]](P).
11. If targetDesc is not undefined and targetDesc.[[Configurable]] is false, then
    1. If IsDataDescriptor(targetDesc) is true and targetDesc.[[Writable]] is false, then
       1. If SameValue(V, targetDesc.[[Value]]) is false, throw a TypeError exception.
    2. If IsAccessorDescriptor(targetDesc) is true, then
       1. If targetDesc.[[Set]] is undefined, throw a TypeError exception.
12. Return true.

Note

[[Set]] for proxy objects enforces the following invariants:

• The result of [[Set]] is a Boolean value.
• Cannot change the value of a property to be different from the value of the corresponding target object property if the corresponding target object property is a non-writable, non-configurable own data property.
• Cannot set the value of a property if the corresponding target object property is a non-configurable own accessor property that has undefined as its [[Set]] attribute.

When the [[Delete]] internal method of a Proxy exotic object O is called with property key P, the following steps are taken:

1. Assert: IsPropertyKey(P) is true.
2. Let handler be O.[[ProxyHandler]].
3. If handler is null, throw a TypeError exception.
4. Assert: Type(handler) is Object.
5. Let target be O.[[ProxyTarget]].
6. Let trap be ? GetMethod(handler, "deleteProperty").
7. If trap is undefined, then
   1. Return ? target.[[Delete]](P).
8. Let booleanTrapResult be ! ToBoolean(? Call(trap, handler, « target, P »)).
9. If booleanTrapResult is false, return false.
10. Let targetDesc be ? target.[[GetOwnProperty]](P).
11. If targetDesc is undefined, return true.
12. If targetDesc.[[Configurable]] is false, throw a TypeError exception.
13. Let extensibleTarget be ? IsExtensible(target).
14. If extensibleTarget is false, throw a TypeError exception.
15. Return true.

Note

[[Delete]] for proxy objects enforces the following invariants:

• The result of [[Delete]] is a Boolean value.
• A property cannot be reported as deleted, if it exists as a non-configurable own property of the target object.
• A property cannot be reported as deleted, if it exists as an own property of the target object and the target object is non-extensible.

When the [[OwnPropertyKeys]] internal method of a Proxy exotic object O is called, the following steps are taken:

1. Let handler be O.[[ProxyHandler]].
2. If handler is null, throw a TypeError exception.
3. Assert: Type(handler) is Object.
4. Let target be O.[[ProxyTarget]].
5. Let trap be ? GetMethod(handler, "ownKeys").
6. If trap is undefined, then
   1. Return ? target.[[OwnPropertyKeys]]().
7. Let trapResultArray be ? Call(trap, handler, « target »).
8. Let trapResult be ? CreateListFromArrayLike(trapResultArray, « String, Symbol »).
9. If trapResult contains any duplicate entries, throw a TypeError exception.
10. Let extensibleTarget be ? IsExtensible(target).
11. Let targetKeys be ? target.[[OwnPropertyKeys]]().
12. Assert: targetKeys is a List containing only String and Symbol values.
13. Assert: targetKeys contains no duplicate entries.
14. Let targetConfigurableKeys be a new empty List.
15. Let targetNonconfigurableKeys be a new empty List.
16. For each element key of targetKeys, do
    1. Let desc be ? target.[[GetOwnProperty]](key).
    2. If desc is not undefined and desc.[[Configurable]] is false, then
       1. Append key as an element of targetNonconfigurableKeys.
    3. Else,
       1. Append key as an element of targetConfigurableKeys.
17. If extensibleTarget is true and targetNonconfigurableKeys is empty, then
    1. Return trapResult.
18. Let uncheckedResultKeys be a new List which is a copy of trapResult.
19. For each key that is an element of targetNonconfigurableKeys, do
    1. If key is not an element of uncheckedResultKeys, throw a TypeError exception.
    2. Remove key from uncheckedResultKeys.
20. If extensibleTarget is true, return trapResult.
21. For each key that is an element of targetConfigurableKeys, do
    1. If key is not an element of uncheckedResultKeys, throw a TypeError exception.
    2. Remove key from uncheckedResultKeys.
22. If uncheckedResultKeys is not empty, throw a TypeError exception.
23. Return trapResult.

Note

[[OwnPropertyKeys]] for proxy objects enforces the following invariants:

• The result of [[OwnPropertyKeys]] is a List.
• The returned List contains no duplicate entries.
• The Type of each result List element is either String or Symbol.
• The result List must contain the keys of all non-configurable own properties of the target object.
• If the target object is not extensible, then the result List must contain all the keys of the own properties of the target object and no other values.

The [[Call]] internal method of a Proxy exotic object O is called with parameters thisArgument and argumentsList, a List of ECMAScript language values. The following steps are taken:

1. Let handler be O.[[ProxyHandler]].
2. If handler is null, throw a TypeError exception.
3. Assert: Type(handler) is Object.
4. Let target be O.[[ProxyTarget]].
5. Let trap be ? GetMethod(handler, "apply").
6. If trap is undefined, then
   1. Return ? Call(target, thisArgument, argumentsList).
7. Let argArray be ! CreateArrayFromList(argumentsList).
8. Return ? Call(trap, handler, « target, thisArgument, argArray »).

Note

A Proxy exotic object only has a [[Call]] internal method if the initial value of its [[ProxyTarget]] internal slot is an object that has a [[Call]] internal method.