The abstract operation AllocateArrayBuffer takes arguments ctor (a constructor) and byteLength (a non-negative integer) and optional argument maxByteLength (a non-negative integer or empty) and returns either a normal completion containing an ArrayBuffer or a throw completion. It is used to create an ArrayBuffer. It performs the following steps when called:

1. Let slots be « [[ArrayBufferData]], [[ArrayBufferByteLength]], [[ArrayBufferDetachKey]] ».
2. If maxByteLength is present and maxByteLength is not empty, let allocatingResizableBuffer be true; else let allocatingResizableBuffer be false.
3. If allocatingResizableBuffer is true, then
   1. If byteLength > maxByteLength, throw a RangeError exception.
   2. Append [[ArrayBufferMaxByteLength]] to slots.
4. Let obj be ? OrdinaryCreateFromConstructor(ctor, "%ArrayBuffer.prototype%", slots).
5. Let block be ? CreateByteDataBlock(byteLength).
6. Set obj.[[ArrayBufferData]] to block.
7. Set obj.[[ArrayBufferByteLength]] to byteLength.
8. If allocatingResizableBuffer is true, then
   1. If it is not possible to create a Data Block block consisting of maxByteLength bytes, throw a RangeError exception.
   2. NOTE: Resizable ArrayBuffers are designed to be implementable with in-place growth. Implementations may throw if, for example, virtual memory cannot be reserved up front.
   3. Set obj.[[ArrayBufferMaxByteLength]] to maxByteLength.
9. Return obj.

The abstract operation ArrayBufferByteLength takes arguments arrayBuffer (an ArrayBuffer or SharedArrayBuffer) and order (seq-cst or unordered) and returns a non-negative integer. It performs the following steps when called:

1. If IsGrowableSharedArrayBuffer(arrayBuffer) is true, then
   1. Let bufferByteLengthBlock be arrayBuffer.[[ArrayBufferByteLengthData]].
   2. Let rawLength be GetRawBytesFromSharedBlock(bufferByteLengthBlock, 0, biguint64, true, order).
   3. Let agentRecord be the Agent Record of the surrounding agent.
   4. Let isLittleEndian be agentRecord.[[LittleEndian]].
   5. Return ℝ(RawBytesToNumeric(biguint64, rawLength, isLittleEndian)).
2. Assert: IsDetachedBuffer(arrayBuffer) is false.
3. Return arrayBuffer.[[ArrayBufferByteLength]].

The abstract operation ArrayBufferCopyAndDetach takes arguments arrayBuffer (an ECMAScript language value), newLength (an ECMAScript language value), and preserveResizability (preserve-resizability or fixed-length) and returns either a normal completion containing an ArrayBuffer or a throw completion. It performs the following steps when called:

1. Perform ? RequireInternalSlot(arrayBuffer, [[ArrayBufferData]]).
2. If IsSharedArrayBuffer(arrayBuffer) is true, throw a TypeError exception.
3. If newLength is undefined, then
   1. Let newByteLength be arrayBuffer.[[ArrayBufferByteLength]].
4. Else,
   1. Let newByteLength be ? ToIndex(newLength).
5. If IsDetachedBuffer(arrayBuffer) is true, throw a TypeError exception.
6. If preserveResizability is preserve-resizability and IsFixedLengthArrayBuffer(arrayBuffer) is false, then
   1. Let newMaxByteLength be arrayBuffer.[[ArrayBufferMaxByteLength]].
7. Else,
   1. Let newMaxByteLength be empty.
8. If arrayBuffer.[[ArrayBufferDetachKey]] is not undefined, throw a TypeError exception.
9. Let newBuffer be ? AllocateArrayBuffer(%ArrayBuffer%, newByteLength, newMaxByteLength).
10. Let copyLength be min(newByteLength, arrayBuffer.[[ArrayBufferByteLength]]).
11. Let fromBlock be arrayBuffer.[[ArrayBufferData]].
12. Let toBlock be newBuffer.[[ArrayBufferData]].
13. Perform CopyDataBlockBytes(toBlock, 0, fromBlock, 0, copyLength).
14. NOTE: Neither creation of the new Data Block nor copying from the old Data Block are observable. Implementations may implement this method as a zero-copy move or a realloc.
15. Perform ! DetachArrayBuffer(arrayBuffer).
16. Return newBuffer.

The abstract operation IsDetachedBuffer takes argument arrayBuffer (an ArrayBuffer or a SharedArrayBuffer) and returns a Boolean. It performs the following steps when called:

1. If arrayBuffer.[[ArrayBufferData]] is null, return true.
2. Return false.

The abstract operation DetachArrayBuffer takes argument arrayBuffer (an ArrayBuffer) and optional argument key (anything) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

1. Assert: IsSharedArrayBuffer(arrayBuffer) is false.
2. If key is not present, set key to undefined.
3. If arrayBuffer.[[ArrayBufferDetachKey]] is not key, throw a TypeError exception.
4. Set arrayBuffer.[[ArrayBufferData]] to null.
5. Set arrayBuffer.[[ArrayBufferByteLength]] to 0.
6. Return unused.

Note

Detaching an ArrayBuffer instance disassociates the Data Block used as its backing store from the instance and sets the byte length of the buffer to 0.

The abstract operation CloneArrayBuffer takes arguments sourceBuffer (an ArrayBuffer or a SharedArrayBuffer), sourceByteOffset (a non-negative integer), and sourceLength (a non-negative integer) and returns either a normal completion containing an ArrayBuffer or a throw completion. It creates a new ArrayBuffer whose data is a copy of sourceBuffer's data over the range starting at sourceByteOffset and continuing for sourceLength bytes. It performs the following steps when called:

1. Assert: IsDetachedBuffer(sourceBuffer) is false.
2. Let targetBuffer be ? AllocateArrayBuffer(%ArrayBuffer%, sourceLength).
3. Let sourceBlock be sourceBuffer.[[ArrayBufferData]].
4. Let targetBlock be targetBuffer.[[ArrayBufferData]].
5. Perform CopyDataBlockBytes(targetBlock, 0, sourceBlock, sourceByteOffset, sourceLength).
6. Return targetBuffer.

The abstract operation GetArrayBufferMaxByteLengthOption takes argument options (an ECMAScript language value) and returns either a normal completion containing either a non-negative integer or empty, or a throw completion. It performs the following steps when called:

1. If options is not an Object, return empty.
2. Let maxByteLength be ? Get(options, "maxByteLength").
3. If maxByteLength is undefined, return empty.
4. Return ? ToIndex(maxByteLength).

The host-defined abstract operation HostResizeArrayBuffer takes arguments buffer (an ArrayBuffer) and newByteLength (a non-negative integer) and returns either a normal completion containing either handled or unhandled, or a throw completion. It gives the host an opportunity to perform implementation-defined resizing of buffer. If the host chooses not to handle resizing of buffer, it may return unhandled for the default behaviour.

The implementation of HostResizeArrayBuffer must conform to the following requirements:

• The abstract operation does not detach buffer.
• If the abstract operation completes normally with handled, buffer.[[ArrayBufferByteLength]] is newByteLength.

The default implementation of HostResizeArrayBuffer is to return NormalCompletion(unhandled).

The abstract operation IsFixedLengthArrayBuffer takes argument arrayBuffer (an ArrayBuffer or a SharedArrayBuffer) and returns a Boolean. It performs the following steps when called:

1. If arrayBuffer has an [[ArrayBufferMaxByteLength]] internal slot, return false.
2. Return true.

The abstract operation IsUnsignedElementType takes argument type (a TypedArray element type) and returns a Boolean. It verifies if the argument type is an unsigned TypedArray element type. It performs the following steps when called:

1. If type is one of uint8, uint8clamped, uint16, uint32, or biguint64, return true.
2. Return false.

The abstract operation IsUnclampedIntegerElementType takes argument type (a TypedArray element type) and returns a Boolean. It verifies if the argument type is an Integer TypedArray element type not including uint8clamped. It performs the following steps when called:

1. If type is one of int8, uint8, int16, uint16, int32, or uint32, return true.
2. Return false.

The abstract operation IsBigIntElementType takes argument type (a TypedArray element type) and returns a Boolean. It verifies if the argument type is a BigInt TypedArray element type. It performs the following steps when called:

1. If type is either biguint64 or bigint64, return true.
2. Return false.

The abstract operation IsNoTearConfiguration takes arguments type (a TypedArray element type) and order (seq-cst, unordered, or init) and returns a Boolean. It performs the following steps when called:

1. If IsUnclampedIntegerElementType(type) is true, return true.
2. If IsBigIntElementType(type) is true and order is neither init nor unordered, return true.
3. Return false.

The abstract operation RawBytesToNumeric takes arguments type (a TypedArray element type), rawBytes (a List of byte values), and isLittleEndian (a Boolean) and returns a Number or a BigInt. It performs the following steps when called:

1. Let elementSize be the Element Size value specified in Table 70 for Element Type type.
2. If isLittleEndian is false, reverse the order of the elements of rawBytes.
3. If type is float16, then
   1. Let value be the byte elements of rawBytes concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2019 binary16 value.
   2. If value is a NaN, return NaN.
   3. Return the Number value that corresponds to value.
4. If type is float32, then
   1. Let value be the byte elements of rawBytes concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2019 binary32 value.
   2. If value is a NaN, return NaN.
   3. Return the Number value that corresponds to value.
5. If type is float64, then
   1. Let value be the byte elements of rawBytes concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2019 binary64 value.
   2. If value is a NaN, return NaN.
   3. Return the Number value that corresponds to value.
6. If IsUnsignedElementType(type) is true, then
   1. Let intValue be the byte elements of rawBytes concatenated and interpreted as a bit string encoding of an unsigned little-endian binary number.
7. Else,
   1. Let intValue be the byte elements of rawBytes concatenated and interpreted as a bit string encoding of a binary little-endian two's complement number of bit length elementSize × 8.
8. If IsBigIntElementType(type) is true, return the BigInt value that corresponds to intValue.
9. Return the Number value that corresponds to intValue.

The abstract operation GetRawBytesFromSharedBlock takes arguments block (a Shared Data Block), byteIndex (a non-negative integer), type (a TypedArray element type), isTypedArray (a Boolean), and order (seq-cst or unordered) and returns a List of byte values. It performs the following steps when called:

1. Let elementSize be the Element Size value specified in Table 70 for Element Type type.
2. Let agentRecord be the Agent Record of the surrounding agent.
3. Let execution be agentRecord.[[CandidateExecution]].
4. Let eventsRecord be the Agent Events Record of execution.[[EventsRecords]] whose [[AgentSignifier]] is AgentSignifier().
5. If isTypedArray is true and IsNoTearConfiguration(type, order) is true, let noTear be true; else let noTear be false.
6. Let rawValue be a List of length elementSize whose elements are nondeterministically chosen byte values.
7. NOTE: In implementations, rawValue is the result of a non-atomic or atomic read instruction on the underlying hardware. The nondeterminism is a semantic prescription of the memory model to describe observable behaviour of hardware with weak consistency.
8. Let readEvent be ReadSharedMemory { [[Order]]: order, [[NoTear]]: noTear, [[Block]]: block, [[ByteIndex]]: byteIndex, [[ElementSize]]: elementSize }.
9. Append readEvent to eventsRecord.[[EventList]].
10. Append Chosen Value Record { [[Event]]: readEvent, [[ChosenValue]]: rawValue } to execution.[[ChosenValues]].
11. Return rawValue.

The abstract operation GetValueFromBuffer takes arguments arrayBuffer (an ArrayBuffer or SharedArrayBuffer), byteIndex (a non-negative integer), type (a TypedArray element type), isTypedArray (a Boolean), and order (seq-cst or unordered) and optional argument isLittleEndian (a Boolean) and returns a Number or a BigInt. It performs the following steps when called:

1. Assert: IsDetachedBuffer(arrayBuffer) is false.
2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
3. Let block be arrayBuffer.[[ArrayBufferData]].
4. Let elementSize be the Element Size value specified in Table 70 for Element Type type.
5. If IsSharedArrayBuffer(arrayBuffer) is true, then
   1. Assert: block is a Shared Data Block.
   2. Let rawValue be GetRawBytesFromSharedBlock(block, byteIndex, type, isTypedArray, order).
6. Else,
   1. Let rawValue be a List whose elements are bytes from block at indices in the interval from byteIndex (inclusive) to byteIndex + elementSize (exclusive).
7. Assert: The number of elements in rawValue is elementSize.
8. If isLittleEndian is not present, then
   1. Let agentRecord be the Agent Record of the surrounding agent.
   2. Set isLittleEndian to agentRecord.[[LittleEndian]].
9. Return RawBytesToNumeric(type, rawValue, isLittleEndian).

The abstract operation NumericToRawBytes takes arguments type (a TypedArray element type), value (a Number or a BigInt), and isLittleEndian (a Boolean) and returns a List of byte values. It performs the following steps when called:

1. If type is float16, then
   1. Let rawBytes be a List whose elements are the 2 bytes that are the result of converting value to IEEE 754-2019 binary16 format using roundTiesToEven mode. The bytes are arranged in little endian order. If value is NaN, rawBytes may be set to any implementation chosen IEEE 754-2019 binary16 format NaN encoding. An implementation must always choose the same encoding for each implementation distinguishable NaN value.
2. Else if type is float32, then
   1. Let rawBytes be a List whose elements are the 4 bytes that are the result of converting value to IEEE 754-2019 binary32 format using roundTiesToEven mode. The bytes are arranged in little endian order. If value is NaN, rawBytes may be set to any implementation chosen IEEE 754-2019 binary32 format NaN encoding. An implementation must always choose the same encoding for each implementation distinguishable NaN value.
3. Else if type is float64, then
   1. Let rawBytes be a List whose elements are the 8 bytes that are the IEEE 754-2019 binary64 format encoding of value. The bytes are arranged in little endian order. If value is NaN, rawBytes may be set to any implementation chosen IEEE 754-2019 binary64 format NaN encoding. An implementation must always choose the same encoding for each implementation distinguishable NaN value.
4. Else,
   1. Let n be the Element Size value specified in Table 70 for Element Type type.
   2. Let conversionOperation be the abstract operation named in the “Conversion Operation” column of Table 70 for Element Type type.
   3. Let intValue be ℝ(! conversionOperation(value)).
   4. If intValue ≥ 0, then
      1. Let rawBytes be a List whose elements are the n-byte binary encoding of intValue. The bytes are ordered in little endian order.
   5. Else,
      1. Let rawBytes be a List whose elements are the n-byte binary two's complement encoding of intValue. The bytes are ordered in little endian order.
5. If isLittleEndian is false, reverse the order of the elements of rawBytes.
6. Return rawBytes.

The abstract operation SetValueInBuffer takes arguments arrayBuffer (an ArrayBuffer or SharedArrayBuffer), byteIndex (a non-negative integer), type (a TypedArray element type), value (a Number or a BigInt), isTypedArray (a Boolean), and order (seq-cst, unordered, or init) and optional argument isLittleEndian (a Boolean) and returns unused. It performs the following steps when called:

1. Assert: IsDetachedBuffer(arrayBuffer) is false.
2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
3. Assert: value is a BigInt if IsBigIntElementType(type) is true; else, value is a Number.
4. Let block be arrayBuffer.[[ArrayBufferData]].
5. Let elementSize be the Element Size value specified in Table 70 for Element Type type.
6. Let agentRecord be the Agent Record of the surrounding agent.
7. If isLittleEndian is not present, then
   1. Set isLittleEndian to agentRecord.[[LittleEndian]].
8. Let rawBytes be NumericToRawBytes(type, value, isLittleEndian).
9. If IsSharedArrayBuffer(arrayBuffer) is true, then
   1. Let execution be agentRecord.[[CandidateExecution]].
   2. Let eventsRecord be the Agent Events Record of execution.[[EventsRecords]] whose [[AgentSignifier]] is AgentSignifier().
   3. If isTypedArray is true and IsNoTearConfiguration(type, order) is true, let noTear be true; else let noTear be false.
   4. Append WriteSharedMemory { [[Order]]: order, [[NoTear]]: noTear, [[Block]]: block, [[ByteIndex]]: byteIndex, [[ElementSize]]: elementSize, [[Payload]]: rawBytes } to eventsRecord.[[EventList]].
10. Else,
    1. Store the individual bytes of rawBytes into block, starting at block[byteIndex].
11. Return unused.

The abstract operation GetModifySetValueInBuffer takes arguments arrayBuffer (an ArrayBuffer or a SharedArrayBuffer), byteIndex (a non-negative integer), type (a TypedArray element type), value (a Number or a BigInt), and op (a read-modify-write modification function) and returns a Number or a BigInt. It performs the following steps when called:

1. Assert: IsDetachedBuffer(arrayBuffer) is false.
2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
3. Assert: value is a BigInt if IsBigIntElementType(type) is true; else, value is a Number.
4. Let block be arrayBuffer.[[ArrayBufferData]].
5. Let elementSize be the Element Size value specified in Table 70 for Element Type type.
6. Let agentRecord be the Agent Record of the surrounding agent.
7. Let isLittleEndian be agentRecord.[[LittleEndian]].
8. Let rawBytes be NumericToRawBytes(type, value, isLittleEndian).
9. If IsSharedArrayBuffer(arrayBuffer) is true, then
   1. Let execution be agentRecord.[[CandidateExecution]].
   2. Let eventsRecord be the Agent Events Record of execution.[[EventsRecords]] whose [[AgentSignifier]] is AgentSignifier().
   3. Let rawBytesRead be a List of length elementSize whose elements are nondeterministically chosen byte values.
   4. NOTE: In implementations, rawBytesRead is the result of a load-link, of a load-exclusive, or of an operand of a read-modify-write instruction on the underlying hardware. The nondeterminism is a semantic prescription of the memory model to describe observable behaviour of hardware with weak consistency.
   5. Let rmwEvent be ReadModifyWriteSharedMemory { [[Order]]: seq-cst, [[NoTear]]: true, [[Block]]: block, [[ByteIndex]]: byteIndex, [[ElementSize]]: elementSize, [[Payload]]: rawBytes, [[ModifyOp]]: op }.
   6. Append rmwEvent to eventsRecord.[[EventList]].
   7. Append Chosen Value Record { [[Event]]: rmwEvent, [[ChosenValue]]: rawBytesRead } to execution.[[ChosenValues]].
10. Else,
    1. Let rawBytesRead be a List of length elementSize whose elements are the sequence of elementSize bytes starting with block[byteIndex].
    2. Let rawBytesModified be op(rawBytesRead, rawBytes).
    3. Store the individual bytes of rawBytesModified into block, starting at block[byteIndex].
11. Return RawBytesToNumeric(type, rawBytesRead, isLittleEndian).

This function performs the following steps when called:

1. If NewTarget is undefined, throw a TypeError exception.
2. Let byteLength be ? ToIndex(length).
3. Let requestedMaxByteLength be ? GetArrayBufferMaxByteLengthOption(options).
4. Return ? AllocateArrayBuffer(NewTarget, byteLength, requestedMaxByteLength).

This function performs the following steps when called:

1. If arg is not an Object, return false.
2. If arg has a [[ViewedArrayBuffer]] internal slot, return true.
3. Return false.

The initial value of ArrayBuffer.prototype is the ArrayBuffer prototype object.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

ArrayBuffer[%Symbol.species%] is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Return the this value.

The value of the "name" property of this function is "get [Symbol.species]".

Note

ArrayBuffer.prototype.slice ( start, end ) normally uses its this value's constructor to create a derived object. However, a subclass constructor may over-ride that default behaviour for the ArrayBuffer.prototype.slice ( start, end ) method by redefining its %Symbol.species% property.

ArrayBuffer.prototype.byteLength is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferData]]).
3. If IsSharedArrayBuffer(obj) is true, throw a TypeError exception.
4. If IsDetachedBuffer(obj) is true, return +0_𝔽.
5. Let length be obj.[[ArrayBufferByteLength]].
6. Return 𝔽(length).

The initial value of ArrayBuffer.prototype.constructor is %ArrayBuffer%.

ArrayBuffer.prototype.detached is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferData]]).
3. If IsSharedArrayBuffer(obj) is true, throw a TypeError exception.
4. Return IsDetachedBuffer(obj).

ArrayBuffer.prototype.maxByteLength is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferData]]).
3. If IsSharedArrayBuffer(obj) is true, throw a TypeError exception.
4. If IsDetachedBuffer(obj) is true, return +0_𝔽.
5. If IsFixedLengthArrayBuffer(obj) is true, then
   1. Let length be obj.[[ArrayBufferByteLength]].
6. Else,
   1. Let length be obj.[[ArrayBufferMaxByteLength]].
7. Return 𝔽(length).

ArrayBuffer.prototype.resizable is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferData]]).
3. If IsSharedArrayBuffer(obj) is true, throw a TypeError exception.
4. If IsFixedLengthArrayBuffer(obj) is false, return true.
5. Return false.

This method performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferMaxByteLength]]).
3. If IsSharedArrayBuffer(obj) is true, throw a TypeError exception.
4. Let newByteLength be ? ToIndex(newLength).
5. If IsDetachedBuffer(obj) is true, throw a TypeError exception.
6. If newByteLength > obj.[[ArrayBufferMaxByteLength]], throw a RangeError exception.
7. Let hostHandled be ? HostResizeArrayBuffer(obj, newByteLength).
8. If hostHandled is handled, return undefined.
9. Let oldBlock be obj.[[ArrayBufferData]].
10. Let newBlock be ? CreateByteDataBlock(newByteLength).
11. Let copyLength be min(newByteLength, obj.[[ArrayBufferByteLength]]).
12. Perform CopyDataBlockBytes(newBlock, 0, oldBlock, 0, copyLength).
13. NOTE: Neither creation of the new Data Block nor copying from the old Data Block are observable. Implementations may implement this method as in-place growth or shrinkage.
14. Set obj.[[ArrayBufferData]] to newBlock.
15. Set obj.[[ArrayBufferByteLength]] to newByteLength.
16. Return undefined.

This method performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferData]]).
3. If IsSharedArrayBuffer(obj) is true, throw a TypeError exception.
4. If IsDetachedBuffer(obj) is true, throw a TypeError exception.
5. Let length be obj.[[ArrayBufferByteLength]].
6. Let relativeStart be ? ToIntegerOrInfinity(start).
7. If relativeStart = -∞, let first be 0.
8. Else if relativeStart < 0, let first be max(length + relativeStart, 0).
9. Else, let first be min(relativeStart, length).
10. If end is undefined, let relativeEnd be length; else let relativeEnd be ? ToIntegerOrInfinity(end).
11. If relativeEnd = -∞, let final be 0.
12. Else if relativeEnd < 0, let final be max(length + relativeEnd, 0).
13. Else, let final be min(relativeEnd, length).
14. Let newLength be max(final - first, 0).
15. Let ctor be ? SpeciesConstructor(obj, %ArrayBuffer%).
16. Let new be ? Construct(ctor, « 𝔽(newLength) »).
17. Perform ? RequireInternalSlot(new, [[ArrayBufferData]]).
18. If IsSharedArrayBuffer(new) is true, throw a TypeError exception.
19. If IsDetachedBuffer(new) is true, throw a TypeError exception.
20. If SameValue(new, obj) is true, throw a TypeError exception.
21. If new.[[ArrayBufferByteLength]] < newLength, throw a TypeError exception.
22. NOTE: Side-effects of the above steps may have detached or resized obj.
23. If IsDetachedBuffer(obj) is true, throw a TypeError exception.
24. Let fromBuf be obj.[[ArrayBufferData]].
25. Let toBuf be new.[[ArrayBufferData]].
26. Let currentLength be obj.[[ArrayBufferByteLength]].
27. If first < currentLength, then
    1. Let count be min(newLength, currentLength - first).
    2. Perform CopyDataBlockBytes(toBuf, 0, fromBuf, first, count).
28. Return new.

This method performs the following steps when called:

1. Let obj be the this value.
2. Return ? ArrayBufferCopyAndDetach(obj, newLength, preserve-resizability).

This method performs the following steps when called:

1. Let obj be the this value.
2. Return ? ArrayBufferCopyAndDetach(obj, newLength, fixed-length).

The initial value of the %Symbol.toStringTag% property is the String value "ArrayBuffer".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

The abstract operation AllocateSharedArrayBuffer takes arguments ctor (a constructor) and byteLength (a non-negative integer) and optional argument maxByteLength (a non-negative integer or empty) and returns either a normal completion containing a SharedArrayBuffer or a throw completion. It is used to create a SharedArrayBuffer. It performs the following steps when called:

1. Let slots be « [[ArrayBufferData]] ».
2. If maxByteLength is present and maxByteLength is not empty, let allocatingGrowableBuffer be true; else let allocatingGrowableBuffer be false.
3. If allocatingGrowableBuffer is true, then
   1. If byteLength > maxByteLength, throw a RangeError exception.
   2. Append [[ArrayBufferByteLengthData]] and [[ArrayBufferMaxByteLength]] to slots.
4. Else,
   1. Append [[ArrayBufferByteLength]] to slots.
5. Let obj be ? OrdinaryCreateFromConstructor(ctor, "%SharedArrayBuffer.prototype%", slots).
6. If allocatingGrowableBuffer is true, let allocLength be maxByteLength; else let allocLength be byteLength.
7. Let block be ? CreateSharedByteDataBlock(allocLength).
8. Set obj.[[ArrayBufferData]] to block.
9. If allocatingGrowableBuffer is true, then
   1. Assert: byteLength ≤ maxByteLength.
   2. Let byteLengthBlock be ? CreateSharedByteDataBlock(8).
   3. Perform SetValueInBuffer(byteLengthBlock, 0, biguint64, ℤ(byteLength), true, seq-cst).
   4. Set obj.[[ArrayBufferByteLengthData]] to byteLengthBlock.
   5. Set obj.[[ArrayBufferMaxByteLength]] to maxByteLength.
10. Else,
    1. Set obj.[[ArrayBufferByteLength]] to byteLength.
11. Return obj.

The abstract operation IsSharedArrayBuffer takes argument obj (an ArrayBuffer or a SharedArrayBuffer) and returns a Boolean. It tests whether an object is a SharedArrayBuffer. It performs the following steps when called:

1. If obj.[[ArrayBufferData]] is a Shared Data Block, return true.
2. Return false.

The abstract operation IsGrowableSharedArrayBuffer takes argument obj (an ArrayBuffer or a SharedArrayBuffer) and returns a Boolean. It tests whether an object is a growable SharedArrayBuffer. It performs the following steps when called:

1. If IsSharedArrayBuffer(obj) is true and obj has an [[ArrayBufferByteLengthData]] internal slot, return true.
2. Return false.

The host-defined abstract operation HostGrowSharedArrayBuffer takes arguments buffer (a SharedArrayBuffer) and newByteLength (a non-negative integer) and returns either a normal completion containing either handled or unhandled, or a throw completion. It gives the host an opportunity to perform implementation-defined growing of buffer. If the host chooses not to handle growing of buffer, it may return unhandled for the default behaviour.

The implementation of HostGrowSharedArrayBuffer must conform to the following requirements:

• If the abstract operation does not complete normally with unhandled, and newByteLength < the current byte length of the buffer or newByteLength > buffer.[[ArrayBufferMaxByteLength]], throw a RangeError exception.
• Let agentRecord be the Agent Record of the surrounding agent. Let isLittleEndian be agentRecord.[[LittleEndian]]. If the abstract operation completes normally with handled, a WriteSharedMemory or ReadModifyWriteSharedMemory event whose [[Order]] is seq-cst, [[Payload]] is NumericToRawBytes(biguint64, newByteLength, isLittleEndian), [[Block]] is buffer.[[ArrayBufferByteLengthData]], [[ByteIndex]] is 0, and [[ElementSize]] is 8 is added to the surrounding agent's candidate execution such that racing calls to SharedArrayBuffer.prototype.grow ( newLength ) are not “lost”, i.e. silently do nothing.

Note

The second requirement above is intentionally vague about how or when the current byte length of buffer is read. Because the byte length must be updated via an atomic read-modify-write operation on the underlying hardware, architectures that use load-link/store-conditional or load-exclusive/store-exclusive instruction pairs may wish to keep the paired instructions close in the instruction stream. As such, SharedArrayBuffer.prototype.grow ( newLength ) itself does not perform bounds checking on newByteLength before calling HostGrowSharedArrayBuffer, nor is there a requirement on when the current byte length is read.

This is in contrast with HostResizeArrayBuffer, which is guaranteed that 0 ≤ newByteLength ≤ buffer.[[ArrayBufferMaxByteLength]].

The default implementation of HostGrowSharedArrayBuffer is to return NormalCompletion(unhandled).

This function performs the following steps when called:

1. If NewTarget is undefined, throw a TypeError exception.
2. Let byteLength be ? ToIndex(length).
3. Let requestedMaxByteLength be ? GetArrayBufferMaxByteLengthOption(options).
4. Return ? AllocateSharedArrayBuffer(NewTarget, byteLength, requestedMaxByteLength).

The initial value of SharedArrayBuffer.prototype is the SharedArrayBuffer prototype object.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

SharedArrayBuffer[%Symbol.species%] is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Return the this value.

The value of the "name" property of this function is "get [Symbol.species]".

SharedArrayBuffer.prototype.byteLength is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferData]]).
3. If IsSharedArrayBuffer(obj) is false, throw a TypeError exception.
4. Let length be ArrayBufferByteLength(obj, seq-cst).
5. Return 𝔽(length).

The initial value of SharedArrayBuffer.prototype.constructor is %SharedArrayBuffer%.

This method performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferMaxByteLength]]).
3. If IsSharedArrayBuffer(obj) is false, throw a TypeError exception.
4. Let newByteLength be ? ToIndex(newLength).
5. Let hostHandled be ? HostGrowSharedArrayBuffer(obj, newByteLength).
6. If hostHandled is handled, return undefined.
7. Let agentRecord be the Agent Record of the surrounding agent.
8. Let isLittleEndian be agentRecord.[[LittleEndian]].
9. Let byteLengthBlock be obj.[[ArrayBufferByteLengthData]].
10. Let currentByteLengthRawBytes be GetRawBytesFromSharedBlock(byteLengthBlock, 0, biguint64, true, seq-cst).
11. Let newByteLengthRawBytes be NumericToRawBytes(biguint64, ℤ(newByteLength), isLittleEndian).
12. Repeat,
    1. NOTE: This is a compare-and-exchange loop to ensure that parallel, racing grows of the same buffer are totally ordered, are not lost, and do not silently do nothing. The loop exits if it was able to attempt to grow uncontended.
    2. Let currentByteLength be ℝ(RawBytesToNumeric(biguint64, currentByteLengthRawBytes, isLittleEndian)).
    3. If newByteLength = currentByteLength, return undefined.
    4. If newByteLength < currentByteLength or newByteLength > obj.[[ArrayBufferMaxByteLength]], throw a RangeError exception.
    5. Let byteLengthDelta be newByteLength - currentByteLength.
    6. If it is impossible to create a new Shared Data Block value consisting of byteLengthDelta bytes, throw a RangeError exception.
    7. NOTE: No new Shared Data Block is constructed and used here. The observable behaviour of growable SharedArrayBuffers is specified by allocating a max-sized Shared Data Block at construction time, and this step captures the requirement that implementations that run out of memory must throw a RangeError.
    8. Let readByteLengthRawBytes be AtomicCompareExchangeInSharedBlock(byteLengthBlock, 0, 8, currentByteLengthRawBytes, newByteLengthRawBytes).
    9. If ByteListEqual(readByteLengthRawBytes, currentByteLengthRawBytes) is true, return undefined.
    10. Set currentByteLengthRawBytes to readByteLengthRawBytes.

Note

Spurious failures of the compare-exchange to update the length are prohibited. If the bounds checking for the new length passes and the implementation is not out of memory, a ReadModifyWriteSharedMemory event (i.e. a successful compare-exchange) is always added into the candidate execution.

Parallel calls to SharedArrayBuffer.prototype.grow are totally ordered. For example, consider two racing calls: sab.grow(10) and sab.grow(20). One of the two calls is guaranteed to win the race. The call to sab.grow(10) will never shrink sab even if sab.grow(20) happened first; in that case it will instead throw a RangeError.

SharedArrayBuffer.prototype.growable is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferData]]).
3. If IsSharedArrayBuffer(obj) is false, throw a TypeError exception.
4. If IsFixedLengthArrayBuffer(obj) is false, return true.
5. Return false.

SharedArrayBuffer.prototype.maxByteLength is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferData]]).
3. If IsSharedArrayBuffer(obj) is false, throw a TypeError exception.
4. If IsFixedLengthArrayBuffer(obj) is true, then
   1. Let length be obj.[[ArrayBufferByteLength]].
5. Else,
   1. Let length be obj.[[ArrayBufferMaxByteLength]].
6. Return 𝔽(length).

This method performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[ArrayBufferData]]).
3. If IsSharedArrayBuffer(obj) is false, throw a TypeError exception.
4. Let length be ArrayBufferByteLength(obj, seq-cst).
5. Let relativeStart be ? ToIntegerOrInfinity(start).
6. If relativeStart = -∞, let first be 0.
7. Else if relativeStart < 0, let first be max(length + relativeStart, 0).
8. Else, let first be min(relativeStart, length).
9. If end is undefined, let relativeEnd be length; else let relativeEnd be ? ToIntegerOrInfinity(end).
10. If relativeEnd = -∞, let final be 0.
11. Else if relativeEnd < 0, let final be max(length + relativeEnd, 0).
12. Else, let final be min(relativeEnd, length).
13. Let newLength be max(final - first, 0).
14. Let ctor be ? SpeciesConstructor(obj, %SharedArrayBuffer%).
15. Let new be ? Construct(ctor, « 𝔽(newLength) »).
16. Perform ? RequireInternalSlot(new, [[ArrayBufferData]]).
17. If IsSharedArrayBuffer(new) is false, throw a TypeError exception.
18. If new.[[ArrayBufferData]] is obj.[[ArrayBufferData]], throw a TypeError exception.
19. If ArrayBufferByteLength(new, seq-cst) < newLength, throw a TypeError exception.
20. Let fromBuf be obj.[[ArrayBufferData]].
21. Let toBuf be new.[[ArrayBufferData]].
22. Perform CopyDataBlockBytes(toBuf, 0, fromBuf, first, newLength).
23. Return new.

The initial value of the %Symbol.toStringTag% property is the String value "SharedArrayBuffer".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

A DataView With Buffer Witness Record is a Record value used to encapsulate a DataView 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.

DataView With Buffer Witness Records have the fields listed in Table 72.

Field Name	Value	Meaning
[[Object]]	a DataView	The DataView object 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 MakeDataViewWithBufferWitnessRecord takes arguments obj (a DataView) and order (seq-cst or unordered) and returns a DataView 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 DataView With Buffer Witness Record { [[Object]]: obj, [[CachedBufferByteLength]]: byteLength }.

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

1. Assert: IsViewOutOfBounds(viewRecord) is false.
2. Let view be viewRecord.[[Object]].
3. If view.[[ByteLength]] is not auto, return view.[[ByteLength]].
4. Assert: IsFixedLengthArrayBuffer(view.[[ViewedArrayBuffer]]) is false.
5. Let byteOffset be view.[[ByteOffset]].
6. Let byteLength be viewRecord.[[CachedBufferByteLength]].
7. Assert: byteLength is not detached.
8. Return byteLength - byteOffset.

The abstract operation IsViewOutOfBounds takes argument viewRecord (a DataView With Buffer Witness Record) and returns a Boolean. It performs the following steps when called:

1. Let view be viewRecord.[[Object]].
2. Let bufferByteLength be viewRecord.[[CachedBufferByteLength]].
3. If IsDetachedBuffer(view.[[ViewedArrayBuffer]]) is true, then
   1. Assert: bufferByteLength is detached.
   2. Return true.
4. Assert: bufferByteLength is a non-negative integer.
5. Let byteOffsetStart be view.[[ByteOffset]].
6. If view.[[ByteLength]] is auto, then
   1. Let byteOffsetEnd be bufferByteLength.
7. Else,
   1. Let byteOffsetEnd be byteOffsetStart + view.[[ByteLength]].
8. NOTE: A 0-length DataView 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 GetViewValue takes arguments view (an ECMAScript language value), requestIndex (an ECMAScript language value), isLittleEndian (an ECMAScript language value), and type (a TypedArray element type) and returns either a normal completion containing either a Number or a BigInt, or a throw completion. It is used by functions on DataView instances to retrieve values from the view's buffer. It performs the following steps when called:

1. Perform ? RequireInternalSlot(view, [[DataView]]).
2. Assert: view has a [[ViewedArrayBuffer]] internal slot.
3. Let getIndex be ? ToIndex(requestIndex).
4. Set isLittleEndian to ToBoolean(isLittleEndian).
5. Let viewOffset be view.[[ByteOffset]].
6. Let viewRecord be MakeDataViewWithBufferWitnessRecord(view, unordered).
7. NOTE: Bounds checking is not a synchronizing operation when view's backing buffer is a growable SharedArrayBuffer.
8. If IsViewOutOfBounds(viewRecord) is true, throw a TypeError exception.
9. Let viewSize be GetViewByteLength(viewRecord).
10. Let elementSize be the Element Size value specified in Table 70 for Element Type type.
11. If getIndex + elementSize > viewSize, throw a RangeError exception.
12. Let bufferIndex be getIndex + viewOffset.
13. Return GetValueFromBuffer(view.[[ViewedArrayBuffer]], bufferIndex, type, false, unordered, isLittleEndian).

The abstract operation SetViewValue takes arguments view (an ECMAScript language value), requestIndex (an ECMAScript language value), isLittleEndian (an ECMAScript language value), type (a TypedArray element type), and value (an ECMAScript language value) and returns either a normal completion containing undefined or a throw completion. It is used by functions on DataView instances to store values into the view's buffer. It performs the following steps when called:

1. Perform ? RequireInternalSlot(view, [[DataView]]).
2. Assert: view has a [[ViewedArrayBuffer]] internal slot.
3. Let getIndex be ? ToIndex(requestIndex).
4. If IsBigIntElementType(type) is true, let number be ? ToBigInt(value).
5. Else, let number be ? ToNumber(value).
6. Set isLittleEndian to ToBoolean(isLittleEndian).
7. Let viewOffset be view.[[ByteOffset]].
8. Let viewRecord be MakeDataViewWithBufferWitnessRecord(view, unordered).
9. NOTE: Bounds checking is not a synchronizing operation when view's backing buffer is a growable SharedArrayBuffer.
10. If IsViewOutOfBounds(viewRecord) is true, throw a TypeError exception.
11. Let viewSize be GetViewByteLength(viewRecord).
12. Let elementSize be the Element Size value specified in Table 70 for Element Type type.
13. If getIndex + elementSize > viewSize, throw a RangeError exception.
14. Let bufferIndex be getIndex + viewOffset.
15. Perform SetValueInBuffer(view.[[ViewedArrayBuffer]], bufferIndex, type, number, false, unordered, isLittleEndian).
16. Return undefined.

This function performs the following steps when called:

1. If NewTarget is undefined, throw a TypeError exception.
2. Perform ? RequireInternalSlot(buffer, [[ArrayBufferData]]).
3. Let offset be ? ToIndex(byteOffset).
4. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
5. Let bufferByteLength be ArrayBufferByteLength(buffer, seq-cst).
6. If offset > bufferByteLength, throw a RangeError exception.
7. Let bufferIsFixedLength be IsFixedLengthArrayBuffer(buffer).
8. If byteLength is undefined, then
   1. If bufferIsFixedLength is true, then
      1. Let viewByteLength be bufferByteLength - offset.
   2. Else,
      1. Let viewByteLength be auto.
9. Else,
   1. Let viewByteLength be ? ToIndex(byteLength).
   2. If offset + viewByteLength > bufferByteLength, throw a RangeError exception.
10. Let obj be ? OrdinaryCreateFromConstructor(NewTarget, "%DataView.prototype%", « [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], [[ByteOffset]] »).
11. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
12. Set bufferByteLength to ArrayBufferByteLength(buffer, seq-cst).
13. If offset > bufferByteLength, throw a RangeError exception.
14. If byteLength is not undefined, then
    1. If offset + viewByteLength > bufferByteLength, throw a RangeError exception.
15. Set obj.[[ViewedArrayBuffer]] to buffer.
16. Set obj.[[ByteLength]] to viewByteLength.
17. Set obj.[[ByteOffset]] to offset.
18. Return obj.

The initial value of DataView.prototype is the DataView prototype object.

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

DataView.prototype.buffer is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[DataView]]).
3. Assert: obj has a [[ViewedArrayBuffer]] internal slot.
4. Let buffer be obj.[[ViewedArrayBuffer]].
5. Return buffer.

DataView.prototype.byteLength is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[DataView]]).
3. Assert: obj has a [[ViewedArrayBuffer]] internal slot.
4. Let viewRecord be MakeDataViewWithBufferWitnessRecord(obj, seq-cst).
5. If IsViewOutOfBounds(viewRecord) is true, throw a TypeError exception.
6. Let size be GetViewByteLength(viewRecord).
7. Return 𝔽(size).

DataView.prototype.byteOffset is an accessor property whose set accessor function is undefined. Its get accessor function performs the following steps when called:

1. Let obj be the this value.
2. Perform ? RequireInternalSlot(obj, [[DataView]]).
3. Assert: obj has a [[ViewedArrayBuffer]] internal slot.
4. Let viewRecord be MakeDataViewWithBufferWitnessRecord(obj, seq-cst).
5. If IsViewOutOfBounds(viewRecord) is true, throw a TypeError exception.
6. Let offset be obj.[[ByteOffset]].
7. Return 𝔽(offset).

The initial value of DataView.prototype.constructor is %DataView%.

This method performs the following steps when called:

1. Let view be the this value.
2. Return ? GetViewValue(view, byteOffset, littleEndian, bigint64).

This method performs the following steps when called:

1. Let view be the this value.
2. Return ? GetViewValue(view, byteOffset, littleEndian, biguint64).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? GetViewValue(view, byteOffset, littleEndian, float16).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? GetViewValue(view, byteOffset, littleEndian, float32).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? GetViewValue(view, byteOffset, littleEndian, float64).

This method performs the following steps when called:

1. Let view be the this value.
2. Return ? GetViewValue(view, byteOffset, true, int8).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? GetViewValue(view, byteOffset, littleEndian, int16).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? GetViewValue(view, byteOffset, littleEndian, int32).

This method performs the following steps when called:

1. Let view be the this value.
2. Return ? GetViewValue(view, byteOffset, true, uint8).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? GetViewValue(view, byteOffset, littleEndian, uint16).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? GetViewValue(view, byteOffset, littleEndian, uint32).

This method performs the following steps when called:

1. Let view be the this value.
2. Return ? SetViewValue(view, byteOffset, littleEndian, bigint64, value).

This method performs the following steps when called:

1. Let view be the this value.
2. Return ? SetViewValue(view, byteOffset, littleEndian, biguint64, value).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? SetViewValue(view, byteOffset, littleEndian, float16, value).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? SetViewValue(view, byteOffset, littleEndian, float32, value).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? SetViewValue(view, byteOffset, littleEndian, float64, value).

This method performs the following steps when called:

1. Let view be the this value.
2. Return ? SetViewValue(view, byteOffset, true, int8, value).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? SetViewValue(view, byteOffset, littleEndian, int16, value).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? SetViewValue(view, byteOffset, littleEndian, int32, value).

This method performs the following steps when called:

1. Let view be the this value.
2. Return ? SetViewValue(view, byteOffset, true, uint8, value).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? SetViewValue(view, byteOffset, littleEndian, uint16, value).

This method performs the following steps when called:

1. Let view be the this value.
2. If littleEndian is not present, set littleEndian to false.
3. Return ? SetViewValue(view, byteOffset, littleEndian, uint32, value).

The initial value of the %Symbol.toStringTag% property is the String value "DataView".

This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

The abstract operation ValidateIntegerTypedArray takes arguments ta (an ECMAScript language value) and waitable (a Boolean) and returns either a normal completion containing a TypedArray With Buffer Witness Record, or a throw completion. It performs the following steps when called:

1. Let taRecord be ? ValidateTypedArray(ta, unordered).
2. NOTE: Bounds checking is not a synchronizing operation when ta's backing buffer is a growable SharedArrayBuffer.
3. If waitable is true, then
   1. If ta.[[TypedArrayName]] is neither "Int32Array" nor "BigInt64Array", throw a TypeError exception.
4. Else,
   1. Let type be TypedArrayElementType(ta).
   2. If IsUnclampedIntegerElementType(type) is false and IsBigIntElementType(type) is false, throw a TypeError exception.
5. Return taRecord.

The abstract operation ValidateAtomicAccess takes arguments taRecord (a TypedArray With Buffer Witness Record) and requestIndex (an ECMAScript language value) and returns either a normal completion containing a non-negative integer or a throw completion. It performs the following steps when called:

1. Let length be TypedArrayLength(taRecord).
2. Let accessIndex be ? ToIndex(requestIndex).
3. Assert: accessIndex ≥ 0.
4. If accessIndex ≥ length, throw a RangeError exception.
5. Let ta be taRecord.[[Object]].
6. Let elementSize be TypedArrayElementSize(ta).
7. Let offset be ta.[[ByteOffset]].
8. Return (accessIndex × elementSize) + offset.

The abstract operation ValidateAtomicAccessOnIntegerTypedArray takes arguments ta (an ECMAScript language value) and requestIndex (an ECMAScript language value) and returns either a normal completion containing a non-negative integer or a throw completion. It performs the following steps when called:

1. Let taRecord be ? ValidateIntegerTypedArray(ta, false).
2. Return ? ValidateAtomicAccess(taRecord, requestIndex).

The abstract operation RevalidateAtomicAccess takes arguments ta (a TypedArray) and byteIndexInBuffer (a non-negative integer) and returns either a normal completion containing unused or a throw completion. This operation revalidates the index within the backing buffer for atomic operations after all argument coercions are performed in Atomics methods, as argument coercions can have arbitrary side effects, which could cause the buffer to become out of bounds. This operation does not throw when ta's backing buffer is a SharedArrayBuffer. It performs the following steps when called:

1. Let taRecord be MakeTypedArrayWithBufferWitnessRecord(ta, unordered).
2. NOTE: Bounds checking is not a synchronizing operation when ta's backing buffer is a growable SharedArrayBuffer.
3. If IsTypedArrayOutOfBounds(taRecord) is true, throw a TypeError exception.
4. Assert: byteIndexInBuffer ≥ ta.[[ByteOffset]].
5. If byteIndexInBuffer ≥ taRecord.[[CachedBufferByteLength]], throw a RangeError exception.
6. Return unused.

The abstract operation GetWaiterList takes arguments block (a Shared Data Block) and i (a non-negative integer that is evenly divisible by 4) and returns a WaiterList Record. It performs the following steps when called:

1. Assert: i and i + 3 are valid byte offsets within the memory of block.
2. Return the WaiterList Record that is referenced by the pair (block, i).

The abstract operation EnterCriticalSection takes argument waiterList (a WaiterList Record) and returns unused. It performs the following steps when called:

1. Assert: The surrounding agent is not in the critical section for any WaiterList Record.
2. Wait until no agent is in the critical section for waiterList, then enter the critical section for waiterList (without allowing any other agent to enter).
3. If waiterList.[[MostRecentLeaveEvent]] is not empty, then
   1. NOTE: A waiterList whose critical section has been entered at least once has a Synchronize event set by LeaveCriticalSection.
   2. Let agentRecord be the Agent Record of the surrounding agent.
   3. Let execution be agentRecord.[[CandidateExecution]].
   4. Let eventsRecord be the Agent Events Record of execution.[[EventsRecords]] whose [[AgentSignifier]] is AgentSignifier().
   5. Let enterEvent be a new Synchronize event.
   6. Append enterEvent to eventsRecord.[[EventList]].
   7. Append (waiterList.[[MostRecentLeaveEvent]], enterEvent) to eventsRecord.[[AgentSynchronizesWith]].
4. Return unused.

EnterCriticalSection has contention when an agent attempting to enter the critical section must wait for another agent to leave it. When there is no contention, FIFO order of EnterCriticalSection calls is observable. When there is contention, an implementation may choose an arbitrary order but may not cause an agent to wait indefinitely.

The abstract operation LeaveCriticalSection takes argument waiterList (a WaiterList Record) and returns unused. It performs the following steps when called:

1. Assert: The surrounding agent is in the critical section for waiterList.
2. Let agentRecord be the Agent Record of the surrounding agent.
3. Let execution be agentRecord.[[CandidateExecution]].
4. Let eventsRecord be the Agent Events Record of execution.[[EventsRecords]] whose [[AgentSignifier]] is AgentSignifier().
5. Let leaveEvent be a new Synchronize event.
6. Append leaveEvent to eventsRecord.[[EventList]].
7. Set waiterList.[[MostRecentLeaveEvent]] to leaveEvent.
8. Leave the critical section for waiterList.
9. Return unused.

The abstract operation AddWaiter takes arguments waiterList (a WaiterList Record) and waiterRecord (a Waiter Record) and returns unused. It performs the following steps when called:

1. Assert: The surrounding agent is in the critical section for waiterList.
2. Assert: There is no Waiter Record in waiterList.[[Waiters]] whose [[PromiseCapability]] field is waiterRecord.[[PromiseCapability]] and whose [[AgentSignifier]] field is waiterRecord.[[AgentSignifier]].
3. Append waiterRecord to waiterList.[[Waiters]].
4. Return unused.

The abstract operation RemoveWaiter takes arguments waiterList (a WaiterList Record) and waiterRecord (a Waiter Record) and returns unused. It performs the following steps when called:

1. Assert: The surrounding agent is in the critical section for waiterList.
2. Assert: waiterList.[[Waiters]] contains waiterRecord.
3. Remove waiterRecord from waiterList.[[Waiters]].
4. Return unused.

The abstract operation RemoveWaiters takes arguments waiterList (a WaiterList Record) and count (a non-negative integer or +∞) and returns a List of Waiter Records. It performs the following steps when called:

1. Assert: The surrounding agent is in the critical section for waiterList.
2. Let length be the number of elements in waiterList.[[Waiters]].
3. Set count to min(count, length).
4. Let waiters be a List whose elements are the first count elements of waiterList.[[Waiters]].
5. Remove the first count elements of waiterList.[[Waiters]].
6. Return waiters.

The abstract operation SuspendThisAgent takes arguments waiterList (a WaiterList Record) and waiterRecord (a Waiter Record) and returns unused. It performs the following steps when called:

1. Assert: The surrounding agent is in the critical section for waiterList.
2. Assert: waiterList.[[Waiters]] contains waiterRecord.
3. Let thisAgent be AgentSignifier().
4. Assert: waiterRecord.[[AgentSignifier]] is thisAgent.
5. Assert: waiterRecord.[[PromiseCapability]] is blocking.
6. Assert: AgentCanSuspend() is true.
7. Perform LeaveCriticalSection(waiterList) and suspend the surrounding agent until the time is waiterRecord.[[TimeoutTime]], performing the combined operation in such a way that a notification that arrives after the critical section is exited but before the suspension takes effect is not lost. The surrounding agent can only wake from suspension due to a timeout or due to another agent calling NotifyWaiter with arguments waiterList and thisAgent (i.e. via a call to Atomics.notify).
8. Perform EnterCriticalSection(waiterList).
9. Return unused.

The abstract operation NotifyWaiter takes arguments waiterList (a WaiterList Record) and waiterRecord (a Waiter Record) and returns unused. It performs the following steps when called:

1. Assert: The surrounding agent is in the critical section for waiterList.
2. If waiterRecord.[[PromiseCapability]] is blocking, then
   1. Wake the agent whose signifier is waiterRecord.[[AgentSignifier]] from suspension.
   2. NOTE: This causes the agent to resume execution in SuspendThisAgent.
3. Else if AgentSignifier() is waiterRecord.[[AgentSignifier]], then
   1. Let promiseCapability be waiterRecord.[[PromiseCapability]].
   2. Perform ! Call(promiseCapability.[[Resolve]], undefined, « waiterRecord.[[Result]] »).
4. Else,
   1. Perform EnqueueResolveInAgentJob(waiterRecord.[[AgentSignifier]], waiterRecord.[[PromiseCapability]], waiterRecord.[[Result]]).
5. Return unused.

Note

An agent must not access another agent's promise capability in any capacity beyond passing it to the host.

The abstract operation EnqueueResolveInAgentJob takes arguments agentSignifier (an agent signifier), promiseCapability (a PromiseCapability Record), and resolution ("ok" or "timed-out") and returns unused. It performs the following steps when called:

1. Let resolveJob be a new Job Abstract Closure with no parameters that captures agentSignifier, promiseCapability, and resolution and performs the following steps when called:
   1. Assert: AgentSignifier() is agentSignifier.
   2. Perform ! Call(promiseCapability.[[Resolve]], undefined, « resolution »).
   3. Return unused.
2. Let realmInTargetAgent be ! GetFunctionRealm(promiseCapability.[[Resolve]]).
3. Assert: agentSignifier is realmInTargetAgent.[[AgentSignifier]].
4. Perform HostEnqueueGenericJob(resolveJob, realmInTargetAgent).
5. Return unused.

The abstract operation DoWait takes arguments mode (sync or async), ta (an ECMAScript language value), index (an ECMAScript language value), value (an ECMAScript language value), and timeout (an ECMAScript language value) and returns either a normal completion containing either an Object, "not-equal", "timed-out", or "ok", or a throw completion. It performs the following steps when called:

1. Let taRecord be ? ValidateIntegerTypedArray(ta, true).
2. Let buffer be taRecord.[[Object]].[[ViewedArrayBuffer]].
3. If IsSharedArrayBuffer(buffer) is false, throw a TypeError exception.
4. Let byteIndexInBuffer be ? ValidateAtomicAccess(taRecord, index).
5. Let arrayTypeName be ta.[[TypedArrayName]].
6. If arrayTypeName is "BigInt64Array", let expected be ? ToBigInt64(value).
7. Else, let expected be ? ToInt32(value).
8. Let timeoutNumber be ? ToNumber(timeout).
9. If timeoutNumber is either NaN or +∞_𝔽, let realTimeout be +∞.
10. Else if timeoutNumber is -∞_𝔽, let realTimeout be 0.
11. Else, let realTimeout be max(ℝ(timeoutNumber), 0).
12. If mode is sync and AgentCanSuspend() is false, throw a TypeError exception.
13. Let block be buffer.[[ArrayBufferData]].
14. Let waiterList be GetWaiterList(block, byteIndexInBuffer).
15. If mode is sync, then
    1. Let promiseCapability be blocking.
    2. Let resultObj be undefined.
16. Else,
    1. Let promiseCapability be ! NewPromiseCapability(%Promise%).
    2. Let resultObj be OrdinaryObjectCreate(%Object.prototype%).
17. Perform EnterCriticalSection(waiterList).
18. Let elementType be TypedArrayElementType(ta).
19. Let witness be GetValueFromBuffer(buffer, byteIndexInBuffer, elementType, true, seq-cst).
20. If expected ≠ witness, then
    1. Perform LeaveCriticalSection(waiterList).
    2. If mode is sync, return "not-equal".
    3. Perform ! CreateDataPropertyOrThrow(resultObj, "async", false).
    4. Perform ! CreateDataPropertyOrThrow(resultObj, "value", "not-equal").
    5. Return resultObj.
21. If realTimeout = 0 and mode is async, then
    1. NOTE: There is no special handling of synchronous immediate timeouts. Asynchronous immediate timeouts have special handling in order to fail fast and avoid unnecessary Promise jobs.
    2. Perform LeaveCriticalSection(waiterList).
    3. Perform ! CreateDataPropertyOrThrow(resultObj, "async", false).
    4. Perform ! CreateDataPropertyOrThrow(resultObj, "value", "timed-out").
    5. Return resultObj.
22. Let thisAgent be AgentSignifier().
23. Let now be the time value (UTC) identifying the current time.
24. Let additionalTimeout be an implementation-defined non-negative mathematical value.
25. Let timeoutTime be ℝ(now) + realTimeout + additionalTimeout.
26. NOTE: When realTimeout is +∞, timeoutTime is also +∞.
27. Let waiterRecord be a new Waiter Record { [[AgentSignifier]]: thisAgent, [[PromiseCapability]]: promiseCapability, [[TimeoutTime]]: timeoutTime, [[Result]]: "ok" }.
28. Perform AddWaiter(waiterList, waiterRecord).
29. If mode is sync, then
    1. Perform SuspendThisAgent(waiterList, waiterRecord).
30. Else if timeoutTime is finite, then
    1. Perform EnqueueAtomicsWaitAsyncTimeoutJob(waiterList, waiterRecord).
31. Perform LeaveCriticalSection(waiterList).
32. If mode is sync, return waiterRecord.[[Result]].
33. Perform ! CreateDataPropertyOrThrow(resultObj, "async", true).
34. Perform ! CreateDataPropertyOrThrow(resultObj, "value", promiseCapability.[[Promise]]).
35. Return resultObj.

Note

additionalTimeout allows implementations to pad timeouts as necessary, such as for reducing power consumption or coarsening timer resolution to mitigate timing attacks. This value may differ from call to call of DoWait.

The abstract operation EnqueueAtomicsWaitAsyncTimeoutJob takes arguments waiterList (a WaiterList Record) and waiterRecord (a Waiter Record) and returns unused. It performs the following steps when called:

1. Let timeoutJob be a new Job Abstract Closure with no parameters that captures waiterList and waiterRecord and performs the following steps when called:
   1. Perform EnterCriticalSection(waiterList).
   2. If waiterList.[[Waiters]] contains waiterRecord, then
      1. Let timeOfJobExecution be the time value (UTC) identifying the current time.
      2. Assert: ℝ(timeOfJobExecution) ≥ waiterRecord.[[TimeoutTime]] (ignoring potential non-monotonicity of time values).
      3. Set waiterRecord.[[Result]] to "timed-out".
      4. Perform RemoveWaiter(waiterList, waiterRecord).
      5. Perform NotifyWaiter(waiterList, waiterRecord).
   3. Perform LeaveCriticalSection(waiterList).
   4. Return unused.
2. Let now be the time value (UTC) identifying the current time.
3. Let currentRealm be the current Realm Record.
4. Perform HostEnqueueTimeoutJob(timeoutJob, currentRealm, 𝔽(waiterRecord.[[TimeoutTime]]) - now).
5. Return unused.

The abstract operation AtomicCompareExchangeInSharedBlock takes arguments block (a Shared Data Block), byteIndexInBuffer (an integer), elementSize (a non-negative integer), expectedBytes (a List of byte values), and replacementBytes (a List of byte values) and returns a List of byte values. It performs the following steps when called:

1. Let agentRecord be the Agent Record of the surrounding agent.
2. Let execution be agentRecord.[[CandidateExecution]].
3. Let eventsRecord be the Agent Events Record of execution.[[EventsRecords]] whose [[AgentSignifier]] is AgentSignifier().
4. Let rawBytesRead be a List of length elementSize whose elements are nondeterministically chosen byte values.
5. NOTE: In implementations, rawBytesRead is the result of a load-link, of a load-exclusive, or of an operand of a read-modify-write instruction on the underlying hardware. The nondeterminism is a semantic prescription of the memory model to describe observable behaviour of hardware with weak consistency.
6. NOTE: The comparison of the expected value and the read value is performed outside of the read-modify-write modification function to avoid needlessly strong synchronization when the expected value is not equal to the read value.
7. If ByteListEqual(rawBytesRead, expectedBytes) is true, then
   1. Let second be a new read-modify-write modification function with parameters (oldBytes, newBytes) that captures nothing and performs the following steps atomically when called:
      1. Return newBytes.
   2. Let event be ReadModifyWriteSharedMemory { [[Order]]: seq-cst, [[NoTear]]: true, [[Block]]: block, [[ByteIndex]]: byteIndexInBuffer, [[ElementSize]]: elementSize, [[Payload]]: replacementBytes, [[ModifyOp]]: second }.
8. Else,
   1. Let event be ReadSharedMemory { [[Order]]: seq-cst, [[NoTear]]: true, [[Block]]: block, [[ByteIndex]]: byteIndexInBuffer, [[ElementSize]]: elementSize }.
9. Append event to eventsRecord.[[EventList]].
10. Append Chosen Value Record { [[Event]]: event, [[ChosenValue]]: rawBytesRead } to execution.[[ChosenValues]].
11. Return rawBytesRead.

The abstract operation AtomicReadModifyWrite takes arguments ta (an ECMAScript language value), index (an ECMAScript language value), value (an ECMAScript language value), and op (a read-modify-write modification function) and returns either a normal completion containing either a Number or a BigInt, or a throw completion. op takes two List of byte values arguments and returns a List of byte values. This operation atomically loads a value, combines it with another value, and stores the combination. It returns the loaded value. It performs the following steps when called:

1. Let byteIndexInBuffer be ? ValidateAtomicAccessOnIntegerTypedArray(ta, index).
2. If ta.[[ContentType]] is bigint, let coerced be ? ToBigInt(value).
3. Else, let coerced be 𝔽(? ToIntegerOrInfinity(value)).
4. Perform ? RevalidateAtomicAccess(ta, byteIndexInBuffer).
5. Let buffer be ta.[[ViewedArrayBuffer]].
6. Let elementType be TypedArrayElementType(ta).
7. Return GetModifySetValueInBuffer(buffer, byteIndexInBuffer, elementType, coerced, op).

The abstract operation ByteListBitwiseOp takes arguments op (&, ^, or |), xBytes (a List of byte values), and yBytes (a List of byte values) and returns a List of byte values. The operation atomically performs a bitwise operation on all byte values of the arguments and returns a List of byte values. It performs the following steps when called:

1. Assert: xBytes and yBytes have the same number of elements.
2. Let result be a new empty List.
3. Let i be 0.
4. For each element xByte of xBytes, do
   1. Let yByte be yBytes[i].
   2. If op is &, then
      1. Let resultByte be the result of applying the bitwise AND operation to xByte and yByte.
   3. Else if op is ^, then
      1. Let resultByte be the result of applying the bitwise exclusive OR (XOR) operation to xByte and yByte.
   4. Else,
      1. Assert: op is |.
      2. Let resultByte be the result of applying the bitwise inclusive OR operation to xByte and yByte.
   5. Set i to i + 1.
   6. Append resultByte to result.
5. Return result.

The abstract operation ByteListEqual takes arguments xBytes (a List of byte values) and yBytes (a List of byte values) and returns a Boolean. It performs the following steps when called:

1. If xBytes and yBytes do not have the same number of elements, return false.
2. Let i be 0.
3. For each element xByte of xBytes, do
   1. Let yByte be yBytes[i].
   2. If xByte ≠ yByte, return false.
   3. Set i to i + 1.
4. Return true.

The abstract operation ParseJSON takes argument text (a String) and returns either a normal completion containing a Record with fields [[ParseNode]] (a Parse Node) and [[Value]] (an ECMAScript language value), or a throw completion. It performs the following steps when called:

1. If StringToCodePoints(text) is not a valid JSON text as specified in ECMA-404, throw a SyntaxError exception.
2. Let scriptString be the string-concatenation of "(", text, and ");".
3. Let script be ParseText(scriptString, Script).
4. NOTE: The early error rules defined in 13.2.5.1 have special handling for the above invocation of ParseText.
5. Assert: script is a Parse Node.
6. Let result be ! Evaluation of script.
7. NOTE: The PropertyDefinitionEvaluation semantics defined in 13.2.5.6 have special handling for the above evaluation.
8. Assert: result is either a String, a Number, a Boolean, an Object that is defined by either an ArrayLiteral or an ObjectLiteral, or null.
9. Return the Record { [[ParseNode]]: script, [[Value]]: result }.

It is not permitted for a conforming implementation of JSON.parse to extend the JSON grammars. If an implementation wishes to support a modified or extended JSON interchange format it must do so by defining a different parse function.

Note 1

Valid JSON text is a subset of the ECMAScript PrimaryExpression syntax. Step 1 verifies that jsonString conforms to that subset, and step 8 asserts that evaluation returns a value of an appropriate type.

However, because 13.2.5.6 behaves differently during ParseJSON, the same source text can produce different results when evaluated as a PrimaryExpression rather than as JSON. Furthermore, the Early Error for duplicate "__proto__" properties in object literals, which likewise does not apply during ParseJSON, means that not all texts accepted by ParseJSON are valid as a PrimaryExpression, despite matching the grammar.

Note 2

In the case where there are duplicate name Strings within an object, lexically preceding values for the same key shall be overwritten.

A JSON Parse Record is a Record value used to describe the initial state of a value parsed from JSON text.

JSON Parse Records have the fields listed in Table 75.

Field Name	Value	Meaning
[[ParseNode]]	a Parse Node	The context Parse Node.
[[Key]]	a property name	The property name with which [[Value]] is associated.
[[Value]]	an ECMAScript language value	The value produced by evaluation of [[ParseNode]].
[[Elements]]	a List of JSON Parse Records	If [[Value]] is an Array, this contains the JSON Parse Records corresponding with the elements of [[Value]]. Otherwise, this is an empty List.
[[Entries]]	a List of JSON Parse Records	If [[Value]] is a non-Array Object, this contains the JSON Parse Records corresponding with the entries of [[Value]]. Otherwise, this is an empty List.

The abstract operation CreateJSONParseRecord takes arguments parseNode (a Parse Node), key (a property name), and value (an ECMAScript language value) and returns a JSON Parse Record. It recursively combines a parseNode parsed from JSON text and the value produced by its evaluation. It performs the following steps when called:

1. Let typedValueNode be ShallowestContainedJSONValue(parseNode).
2. Assert: typedValueNode is not empty.
3. Let elements be a new empty List.
4. Let entries be a new empty List.
5. If value is an Object, then
   1. Let isArray be ! IsArray(value).
   2. If isArray is true, then
      1. Assert: typedValueNode is an ArrayLiteral Parse Node.
      2. Let contentNodes be the JSONArrayLiteralContentNodes of typedValueNode.
      3. Let length be the number of elements in contentNodes.
      4. Let valueLength be ! LengthOfArrayLike(value).
      5. Assert: valueLength is length.
      6. Let index be 0.
      7. Repeat, while index < length,
         1. Let propertyName be ! ToString(𝔽(index)).
         2. Let elementParseRecord be CreateJSONParseRecord(contentNodes[index], propertyName, ! Get(value, propertyName)).
         3. Append elementParseRecord to elements.
         4. Set index to index + 1.
   3. Else,
      1. Assert: typedValueNode is an ObjectLiteral Parse Node.
      2. Let propertyNodes be the PropertyDefinitionNodes of typedValueNode.
      3. NOTE: Because value was produced from JSON text and has not been modified, all of its property keys are Strings and will be exhaustively enumerated.
      4. Let keys be ! EnumerableOwnProperties(value, key).
      5. For each String propertyKey of keys, do
         1. NOTE: In the case of JSON text specifying multiple name/value pairs with the same name for a single object (such as {"a":"lost","a":"kept"}), the value for the corresponding property of the resulting ECMAScript object is specified by the last pair with that name.
         2. Let propertyDefinition be empty.
         3. For each Parse Node propertyNode of propertyNodes, do
            1. Let propertyName be the PropName of propertyNode.
            2. If propertyName is propertyKey, set propertyDefinition to propertyNode.
         4. Assert: propertyDefinition is PropertyDefinition : PropertyName : AssignmentExpression.
         5. Let propertyValueNode be the AssignmentExpression of propertyDefinition.
         6. Let entryParseRecord be CreateJSONParseRecord(propertyValueNode, propertyKey, ! Get(value, propertyKey)).
         7. Append entryParseRecord to entries.
6. Else,
   1. Assert: typedValueNode is neither an ArrayLiteral Parse Node nor an ObjectLiteral Parse Node.
7. Return the JSON Parse Record { [[ParseNode]]: typedValueNode, [[Key]]: key, [[Value]]: value, [[Elements]]: elements, [[Entries]]: entries }.

The abstract operation InternalizeJSONProperty takes arguments holder (an Object), name (a String), reviver (a function object), and parseRecord (a JSON Parse Record or empty) and returns either a normal completion containing an ECMAScript language value or a throw completion.

Note

This algorithm intentionally does not throw an exception if either [[Delete]] or CreateDataProperty return false.

It performs the following steps when called:

1. Let value be ? Get(holder, name).
2. Let context be OrdinaryObjectCreate(%Object.prototype%).
3. If parseRecord is a JSON Parse Record and SameValue(parseRecord.[[Value]], value) is true, then
   1. If value is not an Object, then
      1. Let parseNode be parseRecord.[[ParseNode]].
      2. Assert: parseNode is neither an ArrayLiteral Parse Node nor an ObjectLiteral Parse Node.
      3. Let sourceText be the source text matched by parseNode.
      4. Perform ! CreateDataPropertyOrThrow(context, "source", CodePointsToString(sourceText)).
   2. Let elementRecords be parseRecord.[[Elements]].
   3. Let entryRecords be parseRecord.[[Entries]].
4. Else,
   1. Let elementRecords be a new empty List.
   2. Let entryRecords be a new empty List.
5. If value is an Object, then
   1. Let isArray be ? IsArray(value).
   2. If isArray is true, then
      1. Let elementRecordsLength be the number of elements in elementRecords.
      2. Let length be ? LengthOfArrayLike(value).
      3. Let index be 0.
      4. Repeat, while index < length,
         1. Let propertyKey be ! ToString(𝔽(index)).
         2. If index < elementRecordsLength, let elementRecord be elementRecords[index]; else let elementRecord be empty.
         3. Let newElement be ? InternalizeJSONProperty(value, propertyKey, reviver, elementRecord).
         4. If newElement is undefined, then
            1. Perform ? value.[[Delete]](propertyKey).
         5. Else,
            1. Perform ? CreateDataProperty(value, propertyKey, newElement).
         6. Set index to index + 1.
   3. Else,
      1. Let keys be ? EnumerableOwnProperties(value, key).
      2. For each String propertyKey of keys, do
         1. If there exists an element entry of entryRecords such that entry.[[Key]] is propertyKey, let entryRecord be entry; else let entryRecord be empty.
         2. Let newElement be ? InternalizeJSONProperty(value, propertyKey, reviver, entryRecord).
         3. If newElement is undefined, then
            1. Perform ? value.[[Delete]](propertyKey).
         4. Else,
            1. Perform ? CreateDataProperty(value, propertyKey, newElement).
6. Return ? Call(reviver, holder, « name, value, context »).

The abstract operation ShallowestContainedJSONValue takes argument root (a Parse Node) and returns a Parse Node or empty. It performs a breadth-first search of the parse tree rooted at root, and returns the first node that is an instance of a nonterminal corresponding to a JSON value, or empty if there is no such node. It performs the following steps when called:

1. Let activeFunc be the active function object.
2. Assert: activeFunc is a JSON.parse built-in function object (see JSON.parse).
3. Let types be « NullLiteral, BooleanLiteral, NumericLiteral, StringLiteral, ArrayLiteral, ObjectLiteral, UnaryExpression ».
4. Let unaryExpr be empty.
5. Let queue be « root ».
6. Repeat, while queue is not empty,
   1. Let candidate be the first element of queue.
   2. Remove the first element from queue.
   3. Let queuedChildren be false.
   4. For each nonterminal type of types, do
      1. If candidate is an instance of type, then
         1. NOTE: In the JSON grammar, a number token may represent a negative value. In ECMAScript, negation is represented as a unary operation in which a UnaryExpression parses to a - followed by a derived UnaryExpression.
         2. If type is UnaryExpression, then
            1. If the parent of candidate is not a UnaryExpression Parse Node, set unaryExpr to candidate.
         3. Else if type is NumericLiteral, then
            1. Assert: candidate is contained within unaryExpr.
            2. Return unaryExpr.
         4. Else,
            1. Return candidate.
      2. If queuedChildren is false, candidate is an instance of a nonterminal, and candidate Contains type is true, then
         1. Let children be a List containing each child node of candidate, in order.
         2. Set queue to the list-concatenation of queue and children.
         3. Set queuedChildren to true.
7. Return empty.

The syntax-directed operation JSONArrayLiteralContentNodes takes no arguments and returns a List of Parse Nodes. It is defined piecewise over the following productions:

ArrayLiteral : [ Elisionopt ] [ ElementList ] [ ElementList , Elisionopt ]

1. Assert: Elision is not present.
2. If ElementList is not present, return a new empty List.
3. Return the JSONArrayLiteralContentNodes of ElementList.

ElementList : Elisionopt AssignmentExpression

1. Assert: Elision is not present.
2. Return « AssignmentExpression ».

ElementList : ElementList , Elisionopt AssignmentExpression

1. Assert: Elision is not present.
2. Let elements be the JSONArrayLiteralContentNodes of the derived ElementList.
3. Return the list-concatenation of elements and « AssignmentExpression ».

ElementList : Elisionopt SpreadElement ElementList , Elisionopt SpreadElement

1. NOTE: JSON text as specified in ECMA-404 does not include SpreadElement.
2. Assert: This step is never reached.