The abstract operation OrdinaryGetPrototypeOf takes argument obj (an Object) and returns an Object or null. It performs the following steps when called:

1. Return obj.[[Prototype]].

The abstract operation OrdinarySetPrototypeOf takes arguments obj (an Object) and proto (an Object or null) and returns a Boolean. It performs the following steps when called:

1. Let current be obj.[[Prototype]].
2. If SameValue(proto, current) is true, return true.
3. Let extensible be obj.[[Extensible]].
4. If extensible is false, return false.
5. Let cursor be proto.
6. Let done be false.
7. Repeat, while done is false,
   1. If cursor is null, then
      1. Set done to true.
   2. Else if SameValue(cursor, obj) is true, then
      1. Return false.
   3. Else,
      1. If cursor.[[GetPrototypeOf]] is not the ordinary object internal method defined in 10.1.1, set done to true.
      2. Else, set cursor to cursor.[[Prototype]].
8. Set obj.[[Prototype]] to proto.
9. Return true.

Note

The loop in step 7 guarantees that there will be no cycles in any prototype chain that only includes objects that use the ordinary object definitions for [[GetPrototypeOf]] and [[SetPrototypeOf]].

The abstract operation OrdinaryIsExtensible takes argument obj (an Object) and returns a Boolean. It performs the following steps when called:

1. Return obj.[[Extensible]].

The abstract operation OrdinaryPreventExtensions takes argument obj (an Object) and returns true. It performs the following steps when called:

1. Set obj.[[Extensible]] to false.
2. Return true.

The abstract operation OrdinaryGetOwnProperty takes arguments obj (an Object) and propertyKey (a property key) and returns a Property Descriptor or undefined. It performs the following steps when called:

1. If obj does not have an own property with key propertyKey, return undefined.
2. Let propertyDesc be a newly created Property Descriptor with no fields.
3. Let ownProperty be obj's own property whose key is propertyKey.
4. If ownProperty is a data property, then
   1. Set propertyDesc.[[Value]] to the value of ownProperty's [[Value]] attribute.
   2. Set propertyDesc.[[Writable]] to the value of ownProperty's [[Writable]] attribute.
5. Else,
   1. Assert: ownProperty is an accessor property.
   2. Set propertyDesc.[[Get]] to the value of ownProperty's [[Get]] attribute.
   3. Set propertyDesc.[[Set]] to the value of ownProperty's [[Set]] attribute.
6. Set propertyDesc.[[Enumerable]] to the value of ownProperty's [[Enumerable]] attribute.
7. Set propertyDesc.[[Configurable]] to the value of ownProperty's [[Configurable]] attribute.
8. Return propertyDesc.

The abstract operation OrdinaryDefineOwnProperty takes arguments obj (an Object), propertyKey (a property key), and propertyDesc (a Property Descriptor) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. Let current be ? obj.[[GetOwnProperty]](propertyKey).
2. Let extensible be ? IsExtensible(obj).
3. Return ValidateAndApplyPropertyDescriptor(obj, propertyKey, extensible, propertyDesc, current).

The abstract operation IsCompatiblePropertyDescriptor takes arguments extensible (a Boolean), propertyDesc (a Property Descriptor), and current (a Property Descriptor or undefined) and returns a Boolean. It performs the following steps when called:

1. Return ValidateAndApplyPropertyDescriptor(undefined, "", extensible, propertyDesc, current).

The abstract operation ValidateAndApplyPropertyDescriptor takes arguments obj (an Object or undefined), propertyKey (a property key), extensible (a Boolean), propertyDesc (a Property Descriptor), and current (a Property Descriptor or undefined) and returns a Boolean. It returns true if and only if propertyDesc can be applied as the property of an object with specified extensibility and current property current while upholding invariants. When such application is possible and obj is not undefined, it is performed for the property named propertyKey (which is created if necessary). It performs the following steps when called:

1. Assert: propertyKey is a property key.
2. If current is undefined, then
   1. If extensible is false, return false.
   2. If obj is undefined, return true.
   3. If IsAccessorDescriptor(propertyDesc) is true, then
      1. Create an own accessor property named propertyKey of object obj whose [[Get]], [[Set]], [[Enumerable]], and [[Configurable]] attributes are set to the value of the corresponding field in propertyDesc if propertyDesc has that field, or to the attribute's default value otherwise.
   4. Else,
      1. Create an own data property named propertyKey of object obj whose [[Value]], [[Writable]], [[Enumerable]], and [[Configurable]] attributes are set to the value of the corresponding field in propertyDesc if propertyDesc has that field, or to the attribute's default value otherwise.
   5. Return true.
3. Assert: current is a fully populated Property Descriptor.
4. If propertyDesc does not have any fields, return true.
5. If current.[[Configurable]] is false, then
   1. If propertyDesc has a [[Configurable]] field and propertyDesc.[[Configurable]] is true, return false.
   2. If propertyDesc has an [[Enumerable]] field and propertyDesc.[[Enumerable]] is not current.[[Enumerable]], return false.
   3. If IsGenericDescriptor(propertyDesc) is false and IsAccessorDescriptor(propertyDesc) is not IsAccessorDescriptor(current), return false.
   4. If IsAccessorDescriptor(current) is true, then
      1. If propertyDesc has a [[Get]] field and SameValue(propertyDesc.[[Get]], current.[[Get]]) is false, return false.
      2. If propertyDesc has a [[Set]] field and SameValue(propertyDesc.[[Set]], current.[[Set]]) is false, return false.
   5. Else if current.[[Writable]] is false, then
      1. If propertyDesc has a [[Writable]] field and propertyDesc.[[Writable]] is true, return false.
      2. NOTE: SameValue returns true for NaN values which may be distinguishable by other means. Returning here ensures that any existing property of obj remains unmodified.
      3. If propertyDesc has a [[Value]] field, return SameValue(propertyDesc.[[Value]], current.[[Value]]).
6. If obj is not undefined, then
   1. If IsDataDescriptor(current) is true and IsAccessorDescriptor(propertyDesc) is true, then
      1. If propertyDesc has a [[Configurable]] field, let configurable be propertyDesc.[[Configurable]]; else let configurable be current.[[Configurable]].
      2. If propertyDesc has an [[Enumerable]] field, let enumerable be propertyDesc.[[Enumerable]]; else let enumerable be current.[[Enumerable]].
      3. Replace the property named propertyKey of object obj with an accessor property whose [[Configurable]] and [[Enumerable]] attributes are set to configurable and enumerable, respectively, and whose [[Get]] and [[Set]] attributes are set to the value of the corresponding field in propertyDesc if propertyDesc has that field, or to the attribute's default value otherwise.
   2. Else if IsAccessorDescriptor(current) is true and IsDataDescriptor(propertyDesc) is true, then
      1. If propertyDesc has a [[Configurable]] field, let configurable be propertyDesc.[[Configurable]]; else let configurable be current.[[Configurable]].
      2. If propertyDesc has an [[Enumerable]] field, let enumerable be propertyDesc.[[Enumerable]]; else let enumerable be current.[[Enumerable]].
      3. Replace the property named propertyKey of object obj with a data property whose [[Configurable]] and [[Enumerable]] attributes are set to configurable and enumerable, respectively, and whose [[Value]] and [[Writable]] attributes are set to the value of the corresponding field in propertyDesc if propertyDesc has that field, or to the attribute's default value otherwise.
   3. Else,
      1. For each field name fieldName of propertyDesc, set the attribute named fieldName of the property named propertyKey of object obj to the value of propertyDesc's fieldName field.
7. Return true.

The abstract operation OrdinaryHasProperty takes arguments obj (an Object) and propertyKey (a property key) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. Let hasOwn be ? obj.[[GetOwnProperty]](propertyKey).
2. If hasOwn is not undefined, return true.
3. Let parent be ? obj.[[GetPrototypeOf]]().
4. If parent is not null, then
   1. Return ? parent.[[HasProperty]](propertyKey).
5. Return false.

The abstract operation OrdinaryGet takes arguments obj (an Object), propertyKey (a property key), and receiver (an ECMAScript language value) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

1. Let propertyDesc be ? obj.[[GetOwnProperty]](propertyKey).
2. If propertyDesc is undefined, then
   1. Let parent be ? obj.[[GetPrototypeOf]]().
   2. If parent is null, return undefined.
   3. Return ? parent.[[Get]](propertyKey, receiver).
3. If IsDataDescriptor(propertyDesc) is true, return propertyDesc.[[Value]].
4. Assert: IsAccessorDescriptor(propertyDesc) is true.
5. Let getter be propertyDesc.[[Get]].
6. If getter is undefined, return undefined.
7. Return ? Call(getter, receiver).

The abstract operation OrdinarySet takes arguments obj (an Object), propertyKey (a property key), value (an ECMAScript language value), and receiver (an ECMAScript language value) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. Let ownDesc be ? obj.[[GetOwnProperty]](propertyKey).
2. Return ? OrdinarySetWithOwnDescriptor(obj, propertyKey, value, receiver, ownDesc).

The abstract operation OrdinarySetWithOwnDescriptor takes arguments obj (an Object), propertyKey (a property key), value (an ECMAScript language value), receiver (an ECMAScript language value), and ownDesc (a Property Descriptor or undefined) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. If ownDesc is undefined, then
   1. Let parent be ? obj.[[GetPrototypeOf]]().
   2. If parent is not null, return ? parent.[[Set]](propertyKey, value, receiver).
   3. Set ownDesc to the PropertyDescriptor { [[Value]]: undefined, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }.
2. If IsDataDescriptor(ownDesc) is true, then
   1. If ownDesc.[[Writable]] is false, return false.
   2. If receiver is not an Object, return false.
   3. Let existingDesc be ? receiver.[[GetOwnProperty]](propertyKey).
   4. If existingDesc is undefined, then
      1. Assert: receiver does not currently have a property propertyKey.
      2. Return ? CreateDataProperty(receiver, propertyKey, value).
   5. If IsAccessorDescriptor(existingDesc) is true, return false.
   6. If existingDesc.[[Writable]] is false, return false.
   7. Let valueDesc be the PropertyDescriptor { [[Value]]: value }.
   8. Return ? receiver.[[DefineOwnProperty]](propertyKey, valueDesc).
3. Assert: IsAccessorDescriptor(ownDesc) is true.
4. Let setter be ownDesc.[[Set]].
5. If setter is undefined, return false.
6. Perform ? Call(setter, receiver, « value »).
7. Return true.

The abstract operation OrdinaryDelete takes arguments obj (an Object) and propertyKey (a property key) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. Let propertyDesc be ? obj.[[GetOwnProperty]](propertyKey).
2. If propertyDesc is undefined, return true.
3. If propertyDesc.[[Configurable]] is true, then
   1. Remove the own property with name propertyKey from obj.
   2. Return true.
4. Return false.

The abstract operation OrdinaryOwnPropertyKeys takes argument obj (an Object) and returns a List of property keys. It performs the following steps when called:

1. Let keys be a new empty List.
2. For each own property key propertyKey of obj such that propertyKey is an array index, in ascending numeric index order, do
   1. Append propertyKey to keys.
3. For each own property key propertyKey of obj such that propertyKey is a String and propertyKey is not an array index, in ascending chronological order of property creation, do
   1. Append propertyKey to keys.
4. For each own property key propertyKey of obj such that propertyKey is a Symbol, in ascending chronological order of property creation, do
   1. Append propertyKey to keys.
5. Return keys.

The abstract operation PrepareForOrdinaryCall takes arguments func (an ECMAScript function object) and newTarget (an Object or undefined) and returns an execution context. It performs the following steps when called:

1. Let callerContext be the running execution context.
2. Let calleeContext be a new ECMAScript code execution context.
3. Set the Function of calleeContext to func.
4. Let calleeRealm be func.[[Realm]].
5. Set the Realm of calleeContext to calleeRealm.
6. Set the ScriptOrModule of calleeContext to func.[[ScriptOrModule]].
7. Let localEnv be NewFunctionEnvironment(func, newTarget).
8. Set the LexicalEnvironment of calleeContext to localEnv.
9. Set the VariableEnvironment of calleeContext to localEnv.
10. Set the PrivateEnvironment of calleeContext to func.[[PrivateEnvironment]].
11. If callerContext is not already suspended, suspend callerContext.
12. Push calleeContext onto the execution context stack; calleeContext is now the running execution context.
13. NOTE: Any exception objects produced after this point are associated with calleeRealm.
14. Return calleeContext.

The abstract operation OrdinaryCallBindThis takes arguments func (an ECMAScript function object), calleeContext (an execution context), and thisArg (an ECMAScript language value) and returns unused. It performs the following steps when called:

1. Let thisMode be func.[[ThisMode]].
2. If thisMode is lexical, return unused.
3. Let calleeRealm be func.[[Realm]].
4. Let localEnv be the LexicalEnvironment of calleeContext.
5. If thisMode is strict, then
   1. Let thisValue be thisArg.
6. Else,
   1. If thisArg is either undefined or null, then
      1. Let globalEnv be calleeRealm.[[GlobalEnv]].
      2. Assert: globalEnv is a Global Environment Record.
      3. Let thisValue be globalEnv.[[GlobalThisValue]].
   2. Else,
      1. Let thisValue be ! ToObject(thisArg).
      2. NOTE: ToObject produces wrapper objects using calleeRealm.
7. Assert: localEnv is a Function Environment Record.
8. Assert: The next step never returns an abrupt completion because localEnv.[[ThisBindingStatus]] is not initialized.
9. Perform ! BindThisValue(localEnv, thisValue).
10. Return unused.

The syntax-directed operation EvaluateBody takes arguments func (an ECMAScript function object) and argList (a List of ECMAScript language values) and returns a return completion or a throw completion. It is defined piecewise over the following productions:

FunctionBody : FunctionStatementList

1. Return ? EvaluateFunctionBody of FunctionBody with arguments func and argList.

ConciseBody : ExpressionBody

1. Return ? EvaluateConciseBody of ConciseBody with arguments func and argList.

GeneratorBody : FunctionBody

1. Return ? EvaluateGeneratorBody of GeneratorBody with arguments func and argList.

AsyncGeneratorBody : FunctionBody

1. Return ? EvaluateAsyncGeneratorBody of AsyncGeneratorBody with arguments func and argList.

AsyncFunctionBody : FunctionBody

1. Return ? EvaluateAsyncFunctionBody of AsyncFunctionBody with arguments func and argList.

AsyncConciseBody : ExpressionBody

1. Return ? EvaluateAsyncConciseBody of AsyncConciseBody with arguments func and argList.

Initializer : = AssignmentExpression

1. Assert: argList is empty.
2. Assert: func.[[ClassFieldInitializerName]] is not empty.
3. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
   1. Let value be ? NamedEvaluation of Initializer with argument func.[[ClassFieldInitializerName]].
4. Else,
   1. Let rhs be ? Evaluation of AssignmentExpression.
   2. Let value be ? GetValue(rhs).
5. Return ReturnCompletion(value).

Note

Even though field initializers constitute a function boundary, calling FunctionDeclarationInstantiation does not have any observable effect and so is omitted.

ClassStaticBlockBody : ClassStaticBlockStatementList

1. Assert: argList is empty.
2. Return ? EvaluateClassStaticBlockBody of ClassStaticBlockBody with argument func.

The abstract operation OrdinaryCallEvaluateBody takes arguments func (an ECMAScript function object) and argList (a List of ECMAScript language values) and returns a return completion or a throw completion. It performs the following steps when called:

1. Return ? EvaluateBody of func.[[ECMAScriptCode]] with arguments func and argList.

This function is the %ThrowTypeError% intrinsic object.

It is an anonymous built-in function object that is defined once for each realm.

It performs the following steps when called:

1. Throw a TypeError exception.

The value of the [[Extensible]] internal slot of this function is false.

The "length" property of this function has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The "name" property of this function has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

The [[Call]] internal method of a bound function exotic object func takes arguments thisArg (an ECMAScript language value) and argList (a List of ECMAScript language values) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

1. Let target be func.[[BoundTargetFunction]].
2. Let boundThis be func.[[BoundThis]].
3. Let boundArgs be func.[[BoundArguments]].
4. Let args be the list-concatenation of boundArgs and argList.
5. Return ? Call(target, boundThis, args).

The [[Construct]] internal method of a bound function exotic object func takes arguments argList (a List of ECMAScript language values) and newTarget (a constructor) and returns either a normal completion containing an Object or a throw completion. It performs the following steps when called:

1. Let target be func.[[BoundTargetFunction]].
2. Assert: IsConstructor(target) is true.
3. Let boundArgs be func.[[BoundArguments]].
4. Let args be the list-concatenation of boundArgs and argList.
5. If SameValue(func, newTarget) is true, set newTarget to target.
6. Return ? Construct(target, args, newTarget).

The abstract operation BoundFunctionCreate takes arguments targetFunc (a function object), boundThis (an ECMAScript language value), and boundArgs (a List of ECMAScript language values) and returns either a normal completion containing a function object or a throw completion. It is used to specify the creation of new bound function exotic objects. It performs the following steps when called:

1. Let proto be ? targetFunc.[[GetPrototypeOf]]().
2. Let internalSlotsList be the list-concatenation of « [[Prototype]], [[Extensible]] » and the internal slots listed in Table 26.
3. Let obj be MakeBasicObject(internalSlotsList).
4. Set obj.[[Prototype]] to proto.
5. Set obj.[[Call]] as specified in 10.4.1.1.
6. If IsConstructor(targetFunc) is true, then
   1. Set obj.[[Construct]] as specified in 10.4.1.2.
7. Set obj.[[BoundTargetFunction]] to targetFunc.
8. Set obj.[[BoundThis]] to boundThis.
9. Set obj.[[BoundArguments]] to boundArgs.
10. Return obj.

The [[DefineOwnProperty]] internal method of an Array exotic object array takes arguments propertyKey (a property key) and propertyDesc (a Property Descriptor) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. If propertyKey is "length", return ? ArraySetLength(array, propertyDesc).
2. If propertyKey is an array index, then
   1. Let lengthDesc be OrdinaryGetOwnProperty(array, "length").
   2. Assert: lengthDesc is not undefined.
   3. Assert: IsDataDescriptor(lengthDesc) is true.
   4. Assert: lengthDesc.[[Configurable]] is false.
   5. Let length be lengthDesc.[[Value]].
   6. Assert: length is a non-negative integral Number.
   7. Let index be ! ToUint32(propertyKey).
   8. If index ≥ length and lengthDesc.[[Writable]] is false, return false.
   9. Let succeeded be ! OrdinaryDefineOwnProperty(array, propertyKey, propertyDesc).
   10. If succeeded is false, return false.
   11. If index ≥ length, then
       1. Set lengthDesc.[[Value]] to index + 1_𝔽.
       2. Set succeeded to ! OrdinaryDefineOwnProperty(array, "length", lengthDesc).
       3. Assert: succeeded is true.
   12. Return true.
3. Return ? OrdinaryDefineOwnProperty(array, propertyKey, propertyDesc).

The abstract operation ArrayCreate takes argument length (a non-negative integer) and optional argument proto (an Object) and returns either a normal completion containing an Array exotic object or a throw completion. It is used to specify the creation of new Arrays. It performs the following steps when called:

1. If length > 2³² - 1, throw a RangeError exception.
2. If proto is not present, set proto to %Array.prototype%.
3. Let array be MakeBasicObject(« [[Prototype]], [[Extensible]] »).
4. Set array.[[Prototype]] to proto.
5. Set array.[[DefineOwnProperty]] as specified in 10.4.2.1.
6. Perform ! OrdinaryDefineOwnProperty(array, "length", PropertyDescriptor { [[Value]]: 𝔽(length), [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
7. Return array.

The abstract operation ArraySpeciesCreate takes arguments originalArray (an Object) and length (a non-negative integer) and returns either a normal completion containing an Object or a throw completion. It is used to specify the creation of a new Array or similar object using a constructor function that is derived from originalArray. It does not enforce that the constructor function returns an Array. It performs the following steps when called:

1. Let isArray be ? IsArray(originalArray).
2. If isArray is false, return ? ArrayCreate(length).
3. Let ctor be ? Get(originalArray, "constructor").
4. If IsConstructor(ctor) is true, then
   1. Let thisRealm be the current Realm Record.
   2. Let ctorRealm be ? GetFunctionRealm(ctor).
   3. If thisRealm and ctorRealm are not the same Realm Record, then
      1. If SameValue(ctor, ctorRealm.[[Intrinsics]].[[%Array%]]) is true, set ctor to undefined.
5. If ctor is an Object, then
   1. Set ctor to ? Get(ctor, %Symbol.species%).
   2. If ctor is null, set ctor to undefined.
6. If ctor is undefined, return ? ArrayCreate(length).
7. If IsConstructor(ctor) is false, throw a TypeError exception.
8. Return ? Construct(ctor, « 𝔽(length) »).

Note

If originalArray was created using the standard built-in Array constructor for a realm that is not the realm of the running execution context, then a new Array is created using the realm of the running execution context. This maintains compatibility with Web browsers that have historically had that behaviour for the Array.prototype methods that now are defined using ArraySpeciesCreate.

The abstract operation ArraySetLength takes arguments array (an Array) and propertyDesc (a Property Descriptor) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. If propertyDesc does not have a [[Value]] field, then
   1. Return ! OrdinaryDefineOwnProperty(array, "length", propertyDesc).
2. Let newLengthDesc be a copy of propertyDesc.
3. Let newLength be ? ToUint32(propertyDesc.[[Value]]).
4. Let numberLength be ? ToNumber(propertyDesc.[[Value]]).
5. If SameValueZero(newLength, numberLength) is false, throw a RangeError exception.
6. Set newLengthDesc.[[Value]] to newLength.
7. Let oldLengthDesc be OrdinaryGetOwnProperty(array, "length").
8. Assert: oldLengthDesc is not undefined.
9. Assert: IsDataDescriptor(oldLengthDesc) is true.
10. Assert: oldLengthDesc.[[Configurable]] is false.
11. Let oldLength be oldLengthDesc.[[Value]].
12. If newLength ≥ oldLength, then
    1. Return ! OrdinaryDefineOwnProperty(array, "length", newLengthDesc).
13. If oldLengthDesc.[[Writable]] is false, return false.
14. If newLengthDesc does not have a [[Writable]] field or newLengthDesc.[[Writable]] is true, then
    1. Let newWritable be true.
15. Else,
    1. NOTE: Setting the [[Writable]] attribute to false is deferred in case any elements cannot be deleted.
    2. Let newWritable be false.
    3. Set newLengthDesc.[[Writable]] to true.
16. Let succeeded be ! OrdinaryDefineOwnProperty(array, "length", newLengthDesc).
17. If succeeded is false, return false.
18. For each own property key propertyKey of array such that propertyKey is an array index and ! ToUint32(propertyKey) ≥ newLength, in descending numeric index order, do
    1. Let deleteSucceeded be ! array.[[Delete]](propertyKey).
    2. If deleteSucceeded is false, then
       1. Set newLengthDesc.[[Value]] to ! ToUint32(propertyKey) + 1_𝔽.
       2. If newWritable is false, set newLengthDesc.[[Writable]] to false.
       3. Perform ! OrdinaryDefineOwnProperty(array, "length", newLengthDesc).
       4. Return false.
19. If newWritable is false, then
    1. Set succeeded to ! OrdinaryDefineOwnProperty(array, "length", PropertyDescriptor { [[Writable]]: false }).
    2. Assert: succeeded is true.
20. Return true.

Note

In steps 3 and 4, if propertyDesc.[[Value]] is an object then its valueOf method is called twice. This is legacy behaviour that was specified with this effect starting with the 2^nd Edition of this specification.

The [[GetOwnProperty]] internal method of a String exotic object string takes argument propertyKey (a property key) and returns a normal completion containing either a Property Descriptor or undefined. It performs the following steps when called:

1. Let propertyDesc be OrdinaryGetOwnProperty(string, propertyKey).
2. If propertyDesc is not undefined, return propertyDesc.
3. Return StringGetOwnProperty(string, propertyKey).

The [[DefineOwnProperty]] internal method of a String exotic object string takes arguments propertyKey (a property key) and propertyDesc (a Property Descriptor) and returns a normal completion containing a Boolean. It performs the following steps when called:

1. Let stringDesc be StringGetOwnProperty(string, propertyKey).
2. If stringDesc is not undefined, then
   1. Let extensible be string.[[Extensible]].
   2. Return IsCompatiblePropertyDescriptor(extensible, propertyDesc, stringDesc).
3. Return ! OrdinaryDefineOwnProperty(string, propertyKey, propertyDesc).

The [[OwnPropertyKeys]] internal method of a String exotic object obj takes no arguments and returns a normal completion containing a List of property keys. It performs the following steps when called:

1. Let keys be a new empty List.
2. Let string be obj.[[StringData]].
3. Assert: string is a String.
4. Let length be the length of string.
5. For each integer i such that 0 ≤ i < length, in ascending order, do
   1. Append ! ToString(𝔽(i)) to keys.
6. For each own property key propertyKey of obj such that propertyKey is an array index and ! ToIntegerOrInfinity(propertyKey) ≥ length, in ascending numeric index order, do
   1. Append propertyKey to keys.
7. For each own property key propertyKey of obj such that propertyKey is a String and propertyKey is not an array index, in ascending chronological order of property creation, do
   1. Append propertyKey to keys.
8. For each own property key propertyKey of obj such that propertyKey is a Symbol, in ascending chronological order of property creation, do
   1. Append propertyKey to keys.
9. Return keys.

The abstract operation StringCreate takes arguments value (a String) and proto (an Object) and returns a String exotic object. It is used to specify the creation of new String exotic objects. It performs the following steps when called:

1. Let string be MakeBasicObject(« [[Prototype]], [[Extensible]], [[StringData]] »).
2. Set string.[[Prototype]] to proto.
3. Set string.[[StringData]] to value.
4. Set string.[[GetOwnProperty]] as specified in 10.4.3.1.
5. Set string.[[DefineOwnProperty]] as specified in 10.4.3.2.
6. Set string.[[OwnPropertyKeys]] as specified in 10.4.3.3.
7. Let length be the length of value.
8. Perform ! DefinePropertyOrThrow(string, "length", PropertyDescriptor { [[Value]]: 𝔽(length), [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }).
9. Return string.

The abstract operation StringGetOwnProperty takes arguments string (an Object that has a [[StringData]] internal slot) and propertyKey (a property key) and returns a Property Descriptor or undefined. It performs the following steps when called:

1. If propertyKey is not a String, return undefined.
2. Let numericIndex be CanonicalNumericIndexString(propertyKey).
3. If numericIndex is not an integral Number, return undefined.
4. If numericIndex is -0_𝔽 or numericIndex < -0_𝔽, return undefined.
5. Let stringData be string.[[StringData]].
6. Assert: stringData is a String.
7. Let length be the length of stringData.
8. If ℝ(numericIndex) ≥ length, return undefined.
9. Let resultString be the substring of stringData from ℝ(numericIndex) to ℝ(numericIndex) + 1.
10. Return the PropertyDescriptor { [[Value]]: resultString, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false }.

The [[GetOwnProperty]] internal method of an arguments exotic object args takes argument propertyKey (a property key) and returns a normal completion containing either a Property Descriptor or undefined. It performs the following steps when called:

1. Let propertyDesc be OrdinaryGetOwnProperty(args, propertyKey).
2. If propertyDesc is undefined, return undefined.
3. Let map be args.[[ParameterMap]].
4. Let isMapped be ! HasOwnProperty(map, propertyKey).
5. If isMapped is true, then
   1. Set propertyDesc.[[Value]] to ! Get(map, propertyKey).
6. Return propertyDesc.

The [[DefineOwnProperty]] internal method of an arguments exotic object args takes arguments propertyKey (a property key) and propertyDesc (a Property Descriptor) and returns a normal completion containing a Boolean. It performs the following steps when called:

1. Let map be args.[[ParameterMap]].
2. Let isMapped be ! HasOwnProperty(map, propertyKey).
3. Let newArgDesc be propertyDesc.
4. If isMapped is true and IsDataDescriptor(propertyDesc) is true, then
   1. If propertyDesc does not have a [[Value]] field, propertyDesc has a [[Writable]] field, and propertyDesc.[[Writable]] is false, then
      1. Set newArgDesc to a copy of propertyDesc.
      2. Set newArgDesc.[[Value]] to ! Get(map, propertyKey).
5. Let allowed be ! OrdinaryDefineOwnProperty(args, propertyKey, newArgDesc).
6. If allowed is false, return false.
7. If isMapped is true, then
   1. If IsAccessorDescriptor(propertyDesc) is true, then
      1. Perform ! map.[[Delete]](propertyKey).
   2. Else,
      1. If propertyDesc has a [[Value]] field, then
         1. Assert: The following Set will succeed, since formal parameters mapped by arguments objects are always writable.
         2. Perform ! Set(map, propertyKey, propertyDesc.[[Value]], false).
      2. If propertyDesc has a [[Writable]] field and propertyDesc.[[Writable]] is false, then
         1. Perform ! map.[[Delete]](propertyKey).
8. Return true.

The [[Get]] internal method of an arguments exotic object args takes arguments propertyKey (a property key) and receiver (an ECMAScript language value) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

1. Let map be args.[[ParameterMap]].
2. Let isMapped be ! HasOwnProperty(map, propertyKey).
3. If isMapped is false, return ? OrdinaryGet(args, propertyKey, receiver).
4. Assert: map contains a formal parameter mapping for propertyKey.
5. Return ! Get(map, propertyKey).

The [[Set]] internal method of an arguments exotic object args takes arguments propertyKey (a property key), value (an ECMAScript language value), and receiver (an ECMAScript language value) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. If SameValue(args, receiver) is false, then
   1. Let isMapped be false.
2. Else,
   1. Let map be args.[[ParameterMap]].
   2. Let isMapped be ! HasOwnProperty(map, propertyKey).
3. If isMapped is true, then
   1. Assert: The following Set will succeed, since formal parameters mapped by arguments objects are always writable.
   2. Perform ! Set(map, propertyKey, value, false).
4. Return ? OrdinarySet(args, propertyKey, value, receiver).

The [[Delete]] internal method of an arguments exotic object args takes argument propertyKey (a property key) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. Let map be args.[[ParameterMap]].
2. Let isMapped be ! HasOwnProperty(map, propertyKey).
3. Let result be ? OrdinaryDelete(args, propertyKey).
4. If result is true and isMapped is true, then
   1. Perform ! map.[[Delete]](propertyKey).
5. Return result.

The abstract operation CreateUnmappedArgumentsObject takes argument argList (a List of ECMAScript language values) and returns an ordinary object. It performs the following steps when called:

1. Let length be the number of elements in argList.
2. Let obj be OrdinaryObjectCreate(%Object.prototype%, « [[ParameterMap]] »).
3. Set obj.[[ParameterMap]] to undefined.
4. Perform ! DefinePropertyOrThrow(obj, "length", PropertyDescriptor { [[Value]]: 𝔽(length), [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }).
5. Let index be 0.
6. Repeat, while index < length,
   1. Let value be argList[index].
   2. Perform ! CreateDataPropertyOrThrow(obj, ! ToString(𝔽(index)), value).
   3. Set index to index + 1.
7. Perform ! DefinePropertyOrThrow(obj, %Symbol.iterator%, PropertyDescriptor { [[Value]]: %Array.prototype.values%, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }).
8. Perform ! DefinePropertyOrThrow(obj, "callee", PropertyDescriptor { [[Get]]: %ThrowTypeError%, [[Set]]: %ThrowTypeError%, [[Enumerable]]: false, [[Configurable]]: false }).
9. Return obj.

The abstract operation CreateMappedArgumentsObject takes arguments func (an ECMAScript function object), formals (a Parse Node), argList (a List of ECMAScript language values), and envRecord (an Environment Record) and returns an arguments exotic object. It performs the following steps when called:

1. Assert: formals does not contain a rest parameter, any binding patterns, or any initializers. It may contain duplicate identifiers.
2. Let length be the number of elements in argList.
3. Let obj be MakeBasicObject(« [[Prototype]], [[Extensible]], [[ParameterMap]] »).
4. Set obj.[[GetOwnProperty]] as specified in 10.4.4.1.
5. Set obj.[[DefineOwnProperty]] as specified in 10.4.4.2.
6. Set obj.[[Get]] as specified in 10.4.4.3.
7. Set obj.[[Set]] as specified in 10.4.4.4.
8. Set obj.[[Delete]] as specified in 10.4.4.5.
9. Set obj.[[Prototype]] to %Object.prototype%.
10. Let map be OrdinaryObjectCreate(null).
11. Set obj.[[ParameterMap]] to map.
12. Let paramNames be the BoundNames of formals.
13. Let paramCount be the number of elements in paramNames.
14. Let index be 0.
15. Repeat, while index < length,
    1. Let value be argList[index].
    2. Perform ! CreateDataPropertyOrThrow(obj, ! ToString(𝔽(index)), value).
    3. Set index to index + 1.
16. Perform ! DefinePropertyOrThrow(obj, "length", PropertyDescriptor { [[Value]]: 𝔽(length), [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }).
17. Let mappedNames be a new empty List.
18. Set index to paramCount - 1.
19. Repeat, while index ≥ 0,
    1. Let name be paramNames[index].
    2. If mappedNames does not contain name, then
       1. Append name to mappedNames.
       2. If index < length, then
          1. Let getter be MakeArgGetter(name, envRecord).
          2. Let setter be MakeArgSetter(name, envRecord).
          3. Perform ! map.[[DefineOwnProperty]](! ToString(𝔽(index)), PropertyDescriptor { [[Set]]: setter, [[Get]]: getter, [[Enumerable]]: false, [[Configurable]]: true }).
    3. Set index to index - 1.
20. Perform ! DefinePropertyOrThrow(obj, %Symbol.iterator%, PropertyDescriptor { [[Value]]: %Array.prototype.values%, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }).
21. Perform ! DefinePropertyOrThrow(obj, "callee", PropertyDescriptor { [[Value]]: func, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }).
22. Return obj.

The [[PreventExtensions]] internal method of a TypedArray obj takes no arguments and returns a normal completion containing a Boolean. It performs the following steps when called:

1. NOTE: The extensibility-related invariants specified in 6.1.7.3 do not allow this method to return true when obj can gain (or lose and then regain) properties, which might occur for properties with integer index names when its underlying buffer is resized.
2. If IsTypedArrayFixedLength(obj) is false, return false.
3. Return OrdinaryPreventExtensions(obj).

The [[GetOwnProperty]] internal method of a TypedArray obj takes argument propertyKey (a property key) and returns a normal completion containing either a Property Descriptor or undefined. It performs the following steps when called:

1. If propertyKey is a String, then
   1. Let numericIndex be CanonicalNumericIndexString(propertyKey).
   2. If numericIndex is not undefined, then
      1. Let value be TypedArrayGetElement(obj, numericIndex).
      2. If value is undefined, return undefined.
      3. Return the PropertyDescriptor { [[Value]]: value, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }.
2. Return OrdinaryGetOwnProperty(obj, propertyKey).

The [[HasProperty]] internal method of a TypedArray obj takes argument propertyKey (a property key) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. If propertyKey is a String, then
   1. Let numericIndex be CanonicalNumericIndexString(propertyKey).
   2. If numericIndex is not undefined, return IsValidIntegerIndex(obj, numericIndex).
2. Return ? OrdinaryHasProperty(obj, propertyKey).

The [[DefineOwnProperty]] internal method of a TypedArray obj takes arguments propertyKey (a property key) and propertyDesc (a Property Descriptor) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. If propertyKey is a String, then
   1. Let numericIndex be CanonicalNumericIndexString(propertyKey).
   2. If numericIndex is not undefined, then
      1. If IsValidIntegerIndex(obj, numericIndex) is false, return false.
      2. If propertyDesc has a [[Configurable]] field and propertyDesc.[[Configurable]] is false, return false.
      3. If propertyDesc has an [[Enumerable]] field and propertyDesc.[[Enumerable]] is false, return false.
      4. If IsAccessorDescriptor(propertyDesc) is true, return false.
      5. If propertyDesc has a [[Writable]] field and propertyDesc.[[Writable]] is false, return false.
      6. If propertyDesc has a [[Value]] field, perform ? TypedArraySetElement(obj, numericIndex, propertyDesc.[[Value]]).
      7. Return true.
2. Return ! OrdinaryDefineOwnProperty(obj, propertyKey, propertyDesc).

The [[Get]] internal method of a TypedArray obj takes arguments propertyKey (a property key) and receiver (an ECMAScript language value) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

1. If propertyKey is a String, then
   1. Let numericIndex be CanonicalNumericIndexString(propertyKey).
   2. If numericIndex is not undefined, then
      1. Return TypedArrayGetElement(obj, numericIndex).
2. Return ? OrdinaryGet(obj, propertyKey, receiver).

The [[Set]] internal method of a TypedArray obj takes arguments propertyKey (a property key), value (an ECMAScript language value), and receiver (an ECMAScript language value) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. If propertyKey is a String, then
   1. Let numericIndex be CanonicalNumericIndexString(propertyKey).
   2. If numericIndex is not undefined, then
      1. If SameValue(obj, receiver) is true, then
         1. Perform ? TypedArraySetElement(obj, numericIndex, value).
         2. Return true.
      2. If IsValidIntegerIndex(obj, numericIndex) is false, return true.
2. Return ? OrdinarySet(obj, propertyKey, value, receiver).

The [[Delete]] internal method of a TypedArray obj takes argument propertyKey (a property key) and returns a normal completion containing a Boolean. It performs the following steps when called:

1. If propertyKey is a String, then
   1. Let numericIndex be CanonicalNumericIndexString(propertyKey).
   2. If numericIndex is not undefined, then
      1. If IsValidIntegerIndex(obj, numericIndex) is false, return true.
      2. Return false.
2. Return ! OrdinaryDelete(obj, propertyKey).

The [[OwnPropertyKeys]] internal method of a TypedArray obj takes no arguments and returns a normal completion containing a List of property keys. It performs the following steps when called:

1. Let taRecord be MakeTypedArrayWithBufferWitnessRecord(obj, seq-cst).
2. Let keys be a new empty List.
3. If IsTypedArrayOutOfBounds(taRecord) is false, then
   1. Let length be TypedArrayLength(taRecord).
   2. For each integer i such that 0 ≤ i < length, in ascending order, do
      1. Append ! ToString(𝔽(i)) to keys.
4. For each own property key propertyKey of obj such that propertyKey is a String and propertyKey is not an integer index, in ascending chronological order of property creation, do
   1. Append propertyKey to keys.
5. For each own property key propertyKey of obj such that propertyKey is a Symbol, in ascending chronological order of property creation, do
   1. Append propertyKey to keys.
6. Return keys.

An TypedArray With Buffer Witness Record is a Record value used to encapsulate a TypedArray along with a cached byte length of the viewed buffer. It is used to help ensure there is a single ReadSharedMemory event of the byte length data block when the viewed buffer is a growable SharedArrayBuffer.

TypedArray With Buffer Witness Records have the fields listed in Table 27.

Field Name	Value	Meaning
[[Object]]	a TypedArray	The TypedArray whose buffer's byte length is loaded.
[[CachedBufferByteLength]]	a non-negative integer or detached	The byte length of the object's [[ViewedArrayBuffer]] when the Record was created.

The abstract operation MakeTypedArrayWithBufferWitnessRecord takes arguments obj (a TypedArray) and order (seq-cst or unordered) and returns a TypedArray With Buffer Witness Record. It performs the following steps when called:

1. Let buffer be obj.[[ViewedArrayBuffer]].
2. If IsDetachedBuffer(buffer) is true, then
   1. Let byteLength be detached.
3. Else,
   1. Let byteLength be ArrayBufferByteLength(buffer, order).
4. Return the TypedArray With Buffer Witness Record { [[Object]]: obj, [[CachedBufferByteLength]]: byteLength }.

The abstract operation TypedArrayCreate takes argument proto (an Object) and returns a TypedArray. It is used to specify the creation of new TypedArrays. It performs the following steps when called:

1. Let internalSlotsList be « [[Prototype]], [[Extensible]], [[ViewedArrayBuffer]], [[TypedArrayName]], [[ContentType]], [[ByteLength]], [[ByteOffset]], [[ArrayLength]] ».
2. Let ta be MakeBasicObject(internalSlotsList).
3. Set ta.[[PreventExtensions]] as specified in 10.4.5.1.
4. Set ta.[[GetOwnProperty]] as specified in 10.4.5.2.
5. Set ta.[[HasProperty]] as specified in 10.4.5.3.
6. Set ta.[[DefineOwnProperty]] as specified in 10.4.5.4.
7. Set ta.[[Get]] as specified in 10.4.5.5.
8. Set ta.[[Set]] as specified in 10.4.5.6.
9. Set ta.[[Delete]] as specified in 10.4.5.7.
10. Set ta.[[OwnPropertyKeys]] as specified in 10.4.5.8.
11. Set ta.[[Prototype]] to proto.
12. Return ta.

The abstract operation TypedArrayByteLength takes argument taRecord (a TypedArray With Buffer Witness Record) and returns a non-negative integer. It performs the following steps when called:

1. Assert: IsTypedArrayOutOfBounds(taRecord) is false.
2. Let obj be taRecord.[[Object]].
3. If obj.[[ByteLength]] is not auto, return obj.[[ByteLength]].
4. Let length be TypedArrayLength(taRecord).
5. Let elementSize be TypedArrayElementSize(obj).
6. NOTE: The returned byte length is always an integer multiple of elementSize, even when the underlying buffer has been resized to a non-integer multiple.
7. Return length × elementSize.

The abstract operation TypedArrayLength takes argument taRecord (a TypedArray With Buffer Witness Record) and returns a non-negative integer. It performs the following steps when called:

1. Assert: IsTypedArrayOutOfBounds(taRecord) is false.
2. Let obj be taRecord.[[Object]].
3. If obj.[[ArrayLength]] is not auto, return obj.[[ArrayLength]].
4. Assert: IsFixedLengthArrayBuffer(obj.[[ViewedArrayBuffer]]) is false.
5. Let byteOffset be obj.[[ByteOffset]].
6. Let elementSize be TypedArrayElementSize(obj).
7. Let byteLength be taRecord.[[CachedBufferByteLength]].
8. Assert: byteLength is not detached.
9. Return floor((byteLength - byteOffset) / elementSize).

The abstract operation IsTypedArrayOutOfBounds takes argument taRecord (a TypedArray With Buffer Witness Record) and returns a Boolean. It checks if any of the object's numeric properties reference a value at an index not contained within the underlying buffer's bounds. It performs the following steps when called:

1. Let obj be taRecord.[[Object]].
2. Let bufferByteLength be taRecord.[[CachedBufferByteLength]].
3. If IsDetachedBuffer(obj.[[ViewedArrayBuffer]]) is true, then
   1. Assert: bufferByteLength is detached.
   2. Return true.
4. Assert: bufferByteLength is a non-negative integer.
5. Let byteOffsetStart be obj.[[ByteOffset]].
6. If obj.[[ArrayLength]] is auto, then
   1. Let byteOffsetEnd be bufferByteLength.
7. Else,
   1. Let elementSize be TypedArrayElementSize(obj).
   2. Let arrayByteLength be obj.[[ArrayLength]] × elementSize.
   3. Let byteOffsetEnd be byteOffsetStart + arrayByteLength.
8. NOTE: A 0-length TypedArray whose [[ByteOffset]] is bufferByteLength is not considered out-of-bounds.
9. If byteOffsetStart > bufferByteLength or byteOffsetEnd > bufferByteLength, return true.
10. Return false.

The abstract operation IsTypedArrayFixedLength takes argument obj (a TypedArray) and returns a Boolean. It performs the following steps when called:

1. If obj.[[ArrayLength]] is auto, return false.
2. Let buffer be obj.[[ViewedArrayBuffer]].
3. If IsFixedLengthArrayBuffer(buffer) is false and IsSharedArrayBuffer(buffer) is false, return false.
4. Return true.

The abstract operation IsValidIntegerIndex takes arguments obj (a TypedArray) and index (a Number) and returns a Boolean. It performs the following steps when called:

1. If IsDetachedBuffer(obj.[[ViewedArrayBuffer]]) is true, return false.
2. If index is not an integral Number, return false.
3. If index is -0_𝔽 or index < -0_𝔽, return false.
4. Let taRecord be MakeTypedArrayWithBufferWitnessRecord(obj, unordered).
5. NOTE: Bounds checking is not a synchronizing operation when obj's backing buffer is a growable SharedArrayBuffer.
6. If IsTypedArrayOutOfBounds(taRecord) is true, return false.
7. Let length be TypedArrayLength(taRecord).
8. If ℝ(index) ≥ length, return false.
9. Return true.

The abstract operation TypedArrayGetElement takes arguments obj (a TypedArray) and index (a Number) and returns a Number, a BigInt, or undefined. It performs the following steps when called:

1. If IsValidIntegerIndex(obj, index) is false, return undefined.
2. Let offset be obj.[[ByteOffset]].
3. Let elementSize be TypedArrayElementSize(obj).
4. Let byteIndexInBuffer be (ℝ(index) × elementSize) + offset.
5. Let elementType be TypedArrayElementType(obj).
6. Return GetValueFromBuffer(obj.[[ViewedArrayBuffer]], byteIndexInBuffer, elementType, true, unordered).

The abstract operation TypedArraySetElement takes arguments obj (a TypedArray), index (a Number), and value (an ECMAScript language value) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

1. If obj.[[ContentType]] is bigint, let number be ? ToBigInt(value).
2. Else, let number be ? ToNumber(value).
3. If IsValidIntegerIndex(obj, index) is true, then
   1. Let offset be obj.[[ByteOffset]].
   2. Let elementSize be TypedArrayElementSize(obj).
   3. Let byteIndexInBuffer be (ℝ(index) × elementSize) + offset.
   4. Let elementType be TypedArrayElementType(obj).
   5. Perform SetValueInBuffer(obj.[[ViewedArrayBuffer]], byteIndexInBuffer, elementType, number, true, unordered).
4. Return unused.

Note

This operation always appears to succeed, but it has no effect when attempting to write past the end of a TypedArray or to a TypedArray which is backed by a detached ArrayBuffer.

The abstract operation IsArrayBufferViewOutOfBounds takes argument obj (a TypedArray or a DataView) and returns a Boolean. It checks if either any of a TypedArray's numeric properties or a DataView object's methods can reference a value at an index not contained within the underlying data block's bounds. This abstract operation exists as a convenience for upstream specifications. It performs the following steps when called:

1. If obj has a [[DataView]] internal slot, then
   1. Let viewRecord be MakeDataViewWithBufferWitnessRecord(obj, seq-cst).
   2. Return IsViewOutOfBounds(viewRecord).
2. Let taRecord be MakeTypedArrayWithBufferWitnessRecord(obj, seq-cst).
3. Return IsTypedArrayOutOfBounds(taRecord).

The [[GetPrototypeOf]] internal method of a module namespace exotic object takes no arguments and returns a normal completion containing null. It performs the following steps when called:

1. Return null.

The [[SetPrototypeOf]] internal method of a module namespace exotic object obj takes argument proto (an Object or null) and returns a normal completion containing a Boolean. It performs the following steps when called:

1. Return ! SetImmutablePrototype(obj, proto).

The [[IsExtensible]] internal method of a module namespace exotic object takes no arguments and returns a normal completion containing false. It performs the following steps when called:

1. Return false.

The [[PreventExtensions]] internal method of a module namespace exotic object takes no arguments and returns a normal completion containing true. It performs the following steps when called:

1. Return true.

The [[GetOwnProperty]] internal method of a module namespace exotic object obj takes argument propertyKey (a property key) and returns either a normal completion containing either a Property Descriptor or undefined, or a throw completion. It performs the following steps when called:

1. If propertyKey is a Symbol, return OrdinaryGetOwnProperty(obj, propertyKey).
2. Let exports be obj.[[Exports]].
3. If exports does not contain propertyKey, return undefined.
4. Let value be ? obj.[[Get]](propertyKey, obj).
5. Return PropertyDescriptor { [[Value]]: value, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: false }.

The [[DefineOwnProperty]] internal method of a module namespace exotic object obj takes arguments propertyKey (a property key) and propertyDesc (a Property Descriptor) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. If propertyKey is a Symbol, return ! OrdinaryDefineOwnProperty(obj, propertyKey, propertyDesc).
2. Let current be ? obj.[[GetOwnProperty]](propertyKey).
3. If current is undefined, return false.
4. If propertyDesc has a [[Configurable]] field and propertyDesc.[[Configurable]] is true, return false.
5. If propertyDesc has an [[Enumerable]] field and propertyDesc.[[Enumerable]] is false, return false.
6. If IsAccessorDescriptor(propertyDesc) is true, return false.
7. If propertyDesc has a [[Writable]] field and propertyDesc.[[Writable]] is false, return false.
8. If propertyDesc has a [[Value]] field, return SameValue(propertyDesc.[[Value]], current.[[Value]]).
9. Return true.

The [[HasProperty]] internal method of a module namespace exotic object obj takes argument propertyKey (a property key) and returns a normal completion containing a Boolean. It performs the following steps when called:

1. If propertyKey is a Symbol, return ! OrdinaryHasProperty(obj, propertyKey).
2. Let exports be obj.[[Exports]].
3. If exports contains propertyKey, return true.
4. Return false.

The [[Get]] internal method of a module namespace exotic object obj takes arguments propertyKey (a property key) and receiver (an ECMAScript language value) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

1. If propertyKey is a Symbol, then
   1. Return ! OrdinaryGet(obj, propertyKey, receiver).
2. Let exports be obj.[[Exports]].
3. If exports does not contain propertyKey, return undefined.
4. Let module be obj.[[Module]].
5. Let binding be module.ResolveExport(propertyKey).
6. Assert: binding is a ResolvedBinding Record.
7. Let targetModule be binding.[[Module]].
8. Assert: targetModule is not undefined.
9. If binding.[[BindingName]] is namespace, then
   1. Return GetModuleNamespace(targetModule).
10. Let targetEnv be targetModule.[[Environment]].
11. If targetEnv is empty, throw a ReferenceError exception.
12. Return ? targetEnv.GetBindingValue(binding.[[BindingName]], true).

Note

ResolveExport is side-effect free. Each time this operation is called with a specific exportName, resolveSet pair as arguments it must return the same result. An implementation might choose to pre-compute or cache the ResolveExport results for the [[Exports]] of each module namespace exotic object.

The [[Set]] internal method of a module namespace exotic object takes arguments propertyKey (a property key), value (an ECMAScript language value), and receiver (an ECMAScript language value) and returns a normal completion containing false. It performs the following steps when called:

1. Return false.

The [[Delete]] internal method of a module namespace exotic object obj takes argument propertyKey (a property key) and returns a normal completion containing a Boolean. It performs the following steps when called:

1. If propertyKey is a Symbol, then
   1. Return ! OrdinaryDelete(obj, propertyKey).
2. Let exports be obj.[[Exports]].
3. If exports contains propertyKey, return false.
4. Return true.

The [[OwnPropertyKeys]] internal method of a module namespace exotic object obj takes no arguments and returns a normal completion containing a List of property keys. It performs the following steps when called:

1. Let exports be obj.[[Exports]].
2. Let symbolKeys be OrdinaryOwnPropertyKeys(obj).
3. Return the list-concatenation of exports and symbolKeys.

The abstract operation ModuleNamespaceCreate takes arguments module (a Module Record) and exports (a List of Strings) and returns a module namespace exotic object. It is used to specify the creation of new module namespace exotic objects. It performs the following steps when called:

1. Assert: module.[[Namespace]] is empty.
2. Let internalSlotsList be the internal slots listed in Table 28.
3. Let namespace be MakeBasicObject(internalSlotsList).
4. Set namespace's essential internal methods to the definitions specified in 10.4.6.
5. Set namespace.[[Module]] to module.
6. Let sortedExports be a List whose elements are the elements of exports, sorted according to lexicographic code unit order.
7. Set namespace.[[Exports]] to sortedExports.
8. Create own properties of namespace corresponding to the definitions in 28.3.
9. Set module.[[Namespace]] to namespace.
10. Return namespace.

The [[SetPrototypeOf]] internal method of an immutable prototype exotic object obj takes argument proto (an Object or null) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. Return ? SetImmutablePrototype(obj, proto).

The abstract operation SetImmutablePrototype takes arguments obj (an Object) and proto (an Object or null) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

1. Let current be ? obj.[[GetPrototypeOf]]().
2. If SameValue(proto, current) is true, return true.
3. Return false.