@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/abstract-ops/array-objects.mts

@@ -0,0 +1,311 @@
+import { ValidateTypedArrayBounds } from '../intrinsics/TypedArray.mts';
+import {
+  surroundingAgent, Descriptor, ObjectValue, JSStringValue, Value, wellKnownSymbols, type ObjectInternalMethods,
+  NumberValue, UndefinedValue,
+  BooleanValue,
+  Q, X, type ValueCompletion, type ValueEvaluator,
+  type Mutable, type YieldEvaluator,
+  IsLessThan,
+  Assert,
+  Call,
+  Construct,
+  CreateArrayFromList,
+  CreateIteratorFromClosure,
+  Get,
+  GetFunctionRealm,
+  IsDataDescriptor,
+  IsArray,
+  IsConstructor,
+  OrdinaryDefineOwnProperty,
+  OrdinaryGetOwnProperty,
+  LengthOfArrayLike,
+  MakeBasicObject,
+  SameValue,
+  ToBoolean,
+  ToNumber,
+  ToString,
+  ToUint32,
+  IsPropertyKey,
+  isArrayIndex,
+  isNonNegativeInteger,
+  F, R,
+  type OrdinaryObject,
+  type FunctionObject,
+  type GeneratorObject,
+  TypedArrayLength,
+  CreateIteratorResultObject,
+  GeneratorYield,
+  Throw,
+} from '#self';
+import { isTypedArrayObject } from '#self';
+
+const InternalMethods = {
+  /** https://tc39.es/ecma262/#sec-array-exotic-objects-defineownproperty-p-desc */
+  * DefineOwnProperty(P, Desc): ValueEvaluator<BooleanValue> {
+    const array = this;
+
+    Assert(IsPropertyKey(P));
+    if (P instanceof JSStringValue && P.stringValue() === 'length') {
+      return Q(yield* ArraySetLength(array, Desc));
+    } else if (isArrayIndex(P)) {
+      let lengthDesc = OrdinaryGetOwnProperty(array, Value('length'));
+      Assert(!(lengthDesc instanceof UndefinedValue));
+      Assert(IsDataDescriptor(lengthDesc));
+      Assert(lengthDesc.Configurable === Value.false);
+      const length = lengthDesc.Value;
+      Assert(length instanceof NumberValue && isNonNegativeInteger(R(length)));
+      const index = X(ToUint32(P));
+      if (R(index) >= R(length) && lengthDesc.Writable === Value.false) {
+        return Value.false;
+      }
+      let succeeded = X(OrdinaryDefineOwnProperty(array, P, Desc));
+      if (succeeded === Value.false) {
+        return Value.false;
+      }
+      if (R(index) >= R(length)) {
+        lengthDesc = Descriptor({ ...lengthDesc, Value: F(R(index) + 1) });
+        succeeded = X(OrdinaryDefineOwnProperty(array, Value('length'), lengthDesc));
+        Assert(succeeded === Value.true);
+      }
+      return Value.true;
+    }
+    return yield* OrdinaryDefineOwnProperty(array, P, Desc);
+  },
+} satisfies Partial<ObjectInternalMethods<OrdinaryObject>>;
+
+export { InternalMethods as ArrayExoticObjectInternalMethods };
+
+export function isArrayExoticObject(O: Value) {
+  return O instanceof ObjectValue && O.DefineOwnProperty === InternalMethods.DefineOwnProperty;
+}
+
+/** https://tc39.es/ecma262/#sec-arraycreate */
+export function ArrayCreate(length: number, proto?: ObjectValue): ValueCompletion<OrdinaryObject> {
+  Assert(isNonNegativeInteger(length));
+  if (Object.is(length, -0)) {
+    length = +0;
+  }
+  if (length > (2 ** 32) - 1) {
+    return Throw.RangeError('Array length too big.');
+  }
+  if (proto === undefined) {
+    proto = surroundingAgent.intrinsic('%Array.prototype%');
+  }
+  const array = X(MakeBasicObject(['Prototype', 'Extensible'])) as Mutable<OrdinaryObject>;
+  array.Prototype = proto;
+  array.DefineOwnProperty = InternalMethods.DefineOwnProperty;
+
+  X(OrdinaryDefineOwnProperty(array, Value('length'), Descriptor({
+    Value: F(length),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+
+  return array;
+}
+
+/** https://tc39.es/ecma262/#sec-arrayspeciescreate */
+export function* ArraySpeciesCreate(originalArray: ObjectValue, length: number): ValueEvaluator<ObjectValue> {
+  Assert(typeof length === 'number' && Number.isInteger(length) && length >= 0);
+  if (Object.is(length, -0)) {
+    length = +0;
+  }
+  const isArray = Q(IsArray(originalArray));
+  if (isArray === Value.false) {
+    return Q(ArrayCreate(length));
+  }
+  let constructor = Q(yield* Get(originalArray, Value('constructor')));
+  if (IsConstructor(constructor)) {
+    const thisRealm = surroundingAgent.currentRealmRecord;
+    const constructorRealm = Q(GetFunctionRealm(constructor));
+    if (thisRealm !== constructorRealm) {
+      if (SameValue(constructor, constructorRealm.Intrinsics['%Array%'])) {
+        constructor = Value.undefined;
+      }
+    }
+  }
+  if (constructor instanceof ObjectValue) {
+    constructor = Q(yield* Get(constructor, wellKnownSymbols.species));
+    if (constructor === Value.null) {
+      constructor = Value.undefined;
+    }
+  }
+  if (constructor === Value.undefined) {
+    return Q(ArrayCreate(length));
+  }
+  if (!IsConstructor(constructor)) {
+    return Throw.TypeError('$1 is not a constructor', constructor);
+  }
+  return Q(yield* Construct(constructor, [F(length)]));
+}
+
+/** https://tc39.es/ecma262/#sec-arraysetlength */
+export function* ArraySetLength(array: OrdinaryObject, Desc: Descriptor): ValueEvaluator<BooleanValue> {
+  if (Desc.Value === undefined) {
+    return yield* OrdinaryDefineOwnProperty(array, Value('length'), Desc);
+  }
+  let newLenDesc = Desc;
+  const newLen = R(Q(yield* ToUint32(Desc.Value)));
+  const numberLen = R(Q(yield* ToNumber(Desc.Value)));
+  if (newLen !== numberLen) {
+    return Throw.RangeError('Array length must be uint32.');
+  }
+  newLenDesc = Descriptor({ ...Desc, Value: F(newLen) });
+  const oldLenDesc = OrdinaryGetOwnProperty(array, Value('length'));
+  Assert(!(oldLenDesc instanceof UndefinedValue));
+  Assert(IsDataDescriptor(oldLenDesc));
+  Assert(oldLenDesc.Configurable === Value.false);
+  const oldLen = R(oldLenDesc.Value as NumberValue);
+  if (newLen >= oldLen) {
+    return yield* OrdinaryDefineOwnProperty(array, Value('length'), newLenDesc);
+  }
+  if (oldLenDesc.Writable === Value.false) {
+    return Value.false;
+  }
+  let newWritable;
+  if (newLenDesc.Writable === undefined || newLenDesc.Writable === Value.true) {
+    newWritable = true;
+  } else {
+    newWritable = false;
+    newLenDesc = Descriptor({ ...newLenDesc, Writable: Value.true });
+  }
+  const succeeded = X(OrdinaryDefineOwnProperty(array, Value('length'), newLenDesc));
+  if (succeeded === Value.false) {
+    return Value.false;
+  }
+  const keys: JSStringValue[] = [];
+  array.properties.forEach((_value, key) => {
+    if (isArrayIndex(key) && Number((key as JSStringValue).stringValue()) >= newLen) {
+      keys.push(key as JSStringValue);
+    }
+  });
+  keys.sort((a, b) => Number(b.stringValue()) - Number(a.stringValue()));
+  for (const P of keys) {
+    const deleteSucceeded = X(array.Delete(P));
+    if (deleteSucceeded === Value.false) {
+      newLenDesc = Descriptor({ ...newLenDesc, Value: F(R(X(ToUint32(P))) + 1) });
+      if (newWritable === false) {
+        newLenDesc = Descriptor({ ...newLenDesc, Writable: Value.false });
+      }
+      X(OrdinaryDefineOwnProperty(array, Value('length'), newLenDesc));
+      return Value.false;
+    }
+  }
+  if (newWritable === false) {
+    const s = yield* OrdinaryDefineOwnProperty(array, Value('length'), Descriptor({ Writable: Value.false }));
+    Assert(s === Value.true);
+  }
+  return Value.true;
+}
+
+/** https://tc39.es/ecma262/#sec-isconcatspreadable */
+export function* IsConcatSpreadable(O: Value): ValueEvaluator<BooleanValue> {
+  if (!(O instanceof ObjectValue)) {
+    return Value.false;
+  }
+  const spreadable = Q(yield* Get(O, wellKnownSymbols.isConcatSpreadable));
+  if (spreadable !== Value.undefined) {
+    return ToBoolean(spreadable);
+  }
+  return Q(IsArray(O));
+}
+
+/** https://tc39.es/ecma262/#sec-comparearrayelements */
+export function* CompareArrayElements(x: Value, y: Value, comparefn: FunctionObject | UndefinedValue): ValueEvaluator<NumberValue> {
+  // 1. If x and y are both undefined, return +0𝔽.
+  if (x === Value.undefined && y === Value.undefined) {
+    return F(+0);
+  }
+  // 2. If x is undefined, return 1𝔽.
+  if (x === Value.undefined) {
+    return F(1);
+  }
+  // 3. If y is undefined, return -1𝔽.
+  if (y === Value.undefined) {
+    return F(-1);
+  }
+  // 4. If comparefn is not undefined, then
+  if (comparefn !== Value.undefined) {
+    // a. Let v be ? ToNumber(? Call(comparefn, undefined, « x, y »)).
+    const v = Q(yield* ToNumber(Q(yield* Call(comparefn, Value.undefined, [x, y]))));
+    // b. If v is NaN, return +0𝔽.
+    if (v.isNaN()) {
+      return F(+0);
+    }
+    // c. Return v.
+    return v;
+  }
+  // 5. Let xString be ? ToString(x).
+  const xString = Q(yield* ToString(x));
+  // 6. Let yString be ? ToString(y).
+  const yString = Q(yield* ToString(y));
+  // 7. Let xSmaller be the result of performing Abstract Relational Comparison xString < yString.
+  const xSmaller = yield* IsLessThan(xString, yString);
+  // 8. If xSmaller is true, return -1𝔽.
+  if (xSmaller === Value.true) {
+    return F(-1);
+  }
+  // 9. Let ySmaller be the result of performing Abstract Relational Comparison yString < xString.
+  const ySmaller = yield* IsLessThan(yString, xString);
+  // 10. If ySmaller is true, return 1𝔽.
+  if (ySmaller === Value.true) {
+    return F(1);
+  }
+  // 11. Return +0𝔽.
+  return F(+0);
+}
+
+/** https://tc39.es/ecma262/#sec-createarrayiterator */
+export function CreateArrayIterator(array: ObjectValue, kind: 'key+value' | 'key' | 'value'): ValueCompletion<GeneratorObject> {
+  // 3. Let closure be a new Abstract Closure with no parameters that captures kind and array and performs the following steps when called:
+  const closure = function* closure(): YieldEvaluator {
+    // a. Let index be 0.
+    let index = 0;
+    // b. Repeat,
+    while (true) {
+      let len;
+      let result;
+      // i. If array has a [[TypedArrayName]] internal slot, then
+      if (isTypedArrayObject(array)) {
+        const taRecord = Q(ValidateTypedArrayBounds(array, 'seq-cst'));
+        // 2. Let len be array.[[ArrayLength]].
+        len = TypedArrayLength(taRecord);
+      } else { // ii. Else,
+        // 1. Let len be ? LengthOfArrayLike(array).
+        len = Q(yield* LengthOfArrayLike(array));
+      }
+      // iii. If index ≥ len, return undefined.
+      if (index >= len) {
+        // NON_SPEC
+        generator.HostCapturedValues = undefined;
+        return Value.undefined;
+      }
+      const indexNumber = F(index);
+      // iv. If kind is key,
+      if (kind === 'key') {
+        result = indexNumber;
+      } else { // v. Else,
+        // 1. Let elementKey be ! ToString(indexNumber).
+        const elementKey = X(ToString(indexNumber));
+        // 2. Let elementValue be ? Get(array, elementKey).
+        const elementValue = Q(yield* Get(array, elementKey));
+        // 3. If kind is value, perform ? Yield(elementValue).
+        if (kind === 'value') {
+          result = elementValue;
+        } else { // 4. Else,
+          // a. Assert: kind is key+value.
+          Assert(kind === 'key+value');
+          // b. Perform ? Yield(! CreateArrayFromList(« 𝔽(index), elementValue »)).
+          result = CreateArrayFromList([indexNumber, elementValue]);
+        }
+      }
+      Q(yield* GeneratorYield(CreateIteratorResultObject(result, Value.false)));
+      // vi. Set index to index + 1.
+      index += 1;
+    }
+  };
+  // 4. Return CreateIteratorFromClosure(closure, "%ArrayIteratorPrototype%", %ArrayIteratorPrototype%).
+  const generator = CreateIteratorFromClosure(closure, Value('%ArrayIteratorPrototype%'), surroundingAgent.intrinsic('%ArrayIteratorPrototype%'), ['HostCapturedValues'], [array]);
+  return generator;
+}

package/src/abstract-ops/arraybuffer-objects.mts

@@ -0,0 +1,361 @@
+import { typedArrayInfoByType, type TypedArrayTypes } from '../intrinsics/TypedArray.mts';
+import {
+  decodeFloat16,
+  decodeFloat32,
+  decodeFloat64,
+  encodeFloat16,
+  encodeFloat32,
+  encodeFloat64,
+} from '../host-defined/ieee754.mts';
+import { IsGrowableSharedArrayBuffer, sharedArrayBufferNotSupported } from './shared-arraybuffer.mts';
+import {
+  surroundingAgent,
+  NumberValue, BigIntValue, Value,
+  DataBlock,
+  UndefinedValue,
+  Q, X, NormalCompletion, type ValueEvaluator,
+  type Mutable,
+  Assert, OrdinaryCreateFromConstructor,
+  isNonNegativeInteger, CreateByteDataBlock,
+  SameValue,
+  CopyDataBlockBytes,
+  RequireInternalSlot,
+  F,
+  Z,
+  type FunctionObject,
+  type OrdinaryObject,
+  ObjectValue,
+  Throw,
+  R,
+  Get,
+  ToIndex,
+  type PlainEvaluator,
+} from '#self';
+
+export interface ArrayBufferObject extends OrdinaryObject {
+  readonly ArrayBufferData: DataBlock | null;
+  readonly ArrayBufferByteLength: number;
+  readonly ArrayBufferDetachKey: Value;
+}
+
+export interface ResizableArrayBufferObject extends ArrayBufferObject {
+  readonly ArrayBufferMaxByteLength: number;
+}
+
+export function isArrayBufferObject(o: Value): o is ArrayBufferObject {
+  return 'ArrayBufferDetachKey' in o;
+}
+
+/** https://tc39.es/ecma262/#sec-allocatearraybuffer */
+export function* AllocateArrayBuffer(constructor: FunctionObject, byteLength: number, maxByteLength?: number): ValueEvaluator<ArrayBufferObject> {
+  const slots = ['ArrayBufferData', 'ArrayBufferByteLength', 'ArrayBufferDetachKey'];
+  let allocatingResizableBuffer;
+  if (maxByteLength !== undefined) {
+    allocatingResizableBuffer = true;
+  } else {
+    allocatingResizableBuffer = false;
+  }
+  if (allocatingResizableBuffer) {
+    if (byteLength > maxByteLength!) {
+      return Throw.RangeError('Cannot resize ArrayBuffer to bigger than maxByteLength');
+    }
+    slots.push('ArrayBufferMaxByteLength');
+  }
+  const obj = Q(yield* OrdinaryCreateFromConstructor(constructor, '%ArrayBuffer.prototype%', slots)) as Mutable<ArrayBufferObject & ResizableArrayBufferObject>;
+  // 2. Assert: byteLength is a non-negative integer.
+  Assert(isNonNegativeInteger(byteLength));
+  // 3. Let block be ? CreateByteDataBlock(byteLength).
+  const block = Q(CreateByteDataBlock(byteLength, maxByteLength));
+  // 4. Set obj.[[ArrayBufferData]] to block.
+  obj.ArrayBufferData = block;
+  // 5. Set obj.[[ArrayBufferByteLength]] to byteLength.
+  obj.ArrayBufferByteLength = byteLength;
+  if (allocatingResizableBuffer) {
+    // a. If it is not possible to create a Data Block block consisting of maxByteLength bytes, throw a RangeError exception.
+    if (maxByteLength! > (surroundingAgent.hostDefinedOptions?.resizableArrayBufferMaxByteLength ?? 0xFFFF_FFFF)) {
+      return Throw.RangeError('Cannot allocate memory');
+    }
+    obj.ArrayBufferMaxByteLength = maxByteLength!;
+  }
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-arraybufferbytelength */
+export function ArrayBufferByteLength(arrayBuffer: ArrayBufferObject, _order: 'seq-cst' | 'unordered'): number {
+  if (IsGrowableSharedArrayBuffer(arrayBuffer)) {
+    sharedArrayBufferNotSupported();
+  }
+  Assert(!IsDetachedBuffer(arrayBuffer));
+  return arrayBuffer.ArrayBufferByteLength;
+}
+
+/** https://tc39.es/ecma262/#sec-arraybuffercopyanddetach */
+export function* ArrayBufferCopyAndDetach(
+  _arrayBuffer: Value,
+  newLength: Value,
+  preserveResizability: 'preserve-resizability' | 'fixed-length',
+): ValueEvaluator<ArrayBufferObject> {
+  Q(RequireInternalSlot(_arrayBuffer, 'ArrayBufferData'));
+  const arrayBuffer = _arrayBuffer as Mutable<ArrayBufferObject>;
+  if (IsSharedArrayBuffer(arrayBuffer)) {
+    return Throw.TypeError('Attempt to access shared ArrayBuffer');
+  }
+
+  let newByteLength;
+  if (newLength === Value.undefined) {
+    newByteLength = arrayBuffer.ArrayBufferByteLength;
+  } else {
+    newByteLength = Q(yield* ToIndex(newLength));
+  }
+
+  if (IsDetachedBuffer(arrayBuffer)) {
+    return Throw.TypeError('Attempt to access detached ArrayBuffer');
+  }
+
+  let newMaxByteLength;
+  if (preserveResizability === 'preserve-resizability' && !IsFixedLengthArrayBuffer(arrayBuffer)) {
+    newMaxByteLength = (arrayBuffer as ResizableArrayBufferObject).ArrayBufferMaxByteLength;
+  }
+
+  if (arrayBuffer.ArrayBufferDetachKey !== Value.undefined) {
+    return Throw.TypeError('Cannot transfer ArrayBuffer with custom detach key');
+  }
+
+  const newBuffer = Q(yield* AllocateArrayBuffer(surroundingAgent.intrinsic('%ArrayBuffer%'), newByteLength, newMaxByteLength));
+  const copyLength = Math.min(newByteLength, arrayBuffer.ArrayBufferByteLength);
+  const fromBlock = arrayBuffer.ArrayBufferData!;
+  const toBlock = newBuffer.ArrayBufferData!;
+  CopyDataBlockBytes(toBlock, 0, fromBlock, 0, copyLength);
+  X(DetachArrayBuffer(arrayBuffer));
+  return newBuffer;
+}
+
+/** https://tc39.es/ecma262/#sec-isdetachedbuffer */
+export function IsDetachedBuffer(arrayBuffer: ArrayBufferObject) {
+  if (!arrayBuffer.ArrayBufferData) {
+    return true;
+  }
+  return false;
+}
+
+/** https://tc39.es/ecma262/#sec-detacharraybuffer */
+export function DetachArrayBuffer(arrayBuffer: Mutable<ArrayBufferObject>, key?: Value) {
+  // 2. Assert: IsSharedArrayBuffer(arrayBuffer) is false.
+  Assert(!IsSharedArrayBuffer(arrayBuffer));
+  // 3. If key is not present, set key to undefined.
+  if (key === undefined) {
+    key = Value.undefined;
+  }
+  // 4. If SameValue(arrayBuffer.[[ArrayBufferDetachKey]], key) is false, throw a TypeError exception.
+  if (!SameValue(arrayBuffer.ArrayBufferDetachKey, key)) {
+    return Throw.TypeError('$1 is not the [[ArrayBufferDetachKey]] of the given ArrayBuffer', key);
+  }
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(arrayBuffer));
+  // 5. Set arrayBuffer.[[ArrayBufferData]] to null.
+  arrayBuffer.ArrayBufferData = null;
+  // 6. Set arrayBuffer.[[ArrayBufferByteLength]] to 0.
+  arrayBuffer.ArrayBufferByteLength = 0;
+  return undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-issharedarraybuffer */
+export function IsSharedArrayBuffer(_obj: Value) {
+  return false;
+}
+
+export function* CloneArrayBuffer(srcBuffer: ArrayBufferObject, srcByteOffset: number, srcLength: number): ValueEvaluator<ArrayBufferObject> {
+  Assert(!IsDetachedBuffer(srcBuffer));
+  const targetBuffer = Q(yield* AllocateArrayBuffer(surroundingAgent.intrinsic('%ArrayBuffer%'), srcLength));
+  const srcBlock = srcBuffer.ArrayBufferData!;
+  const targetBlock = targetBuffer.ArrayBufferData!;
+  CopyDataBlockBytes(targetBlock, 0, srcBlock, srcByteOffset, srcLength);
+  return targetBuffer;
+}
+
+/** https://tc39.es/ecma262/#sec-getarraybuffermaxbytelengthoption */
+export function* GetArrayBufferMaxByteLengthOption(options: Value): PlainEvaluator<number | undefined> {
+  if (!(options instanceof ObjectValue)) {
+    return undefined;
+  }
+  const maxByteLength = Q(yield* Get(options, Value('maxByteLength')));
+  if (maxByteLength === Value.undefined) {
+    return undefined;
+  }
+  return Q(yield* ToIndex(maxByteLength));
+}
+
+/** https://tc39.es/ecma262/#sec-hostresizearraybuffer */
+export function HostResizeArrayBuffer(buffer: ArrayBufferObject, newByteLength: number): 'handled' | 'unhandled' {
+  const f = surroundingAgent.hostDefinedOptions.hostHooks?.HostResizeArrayBuffer || (() => {
+    const block = buffer.ArrayBufferData!.buffer;
+    if (!block.resizable) return 'unhandled';
+    try {
+      block.resize(newByteLength);
+      return 'handled';
+    } catch {
+      return 'unhandled';
+    }
+  });
+  const result = f?.(buffer, newByteLength) ?? 'unhandled';
+  if (result === 'handled') {
+    (buffer as Mutable<ArrayBufferObject>).ArrayBufferByteLength = newByteLength;
+  }
+  return result;
+}
+
+/** https://tc39.es/ecma262/#sec-isfixedlengtharraybuffer */
+export function IsFixedLengthArrayBuffer(arrayBuffer: ArrayBufferObject) {
+  return !('ArrayBufferMaxByteLength' in arrayBuffer);
+}
+
+/** https://tc39.es/ecma262/#sec-isunsignedelementtype */
+export function IsUnsignedElementType(type: TypedArrayTypes) {
+  if (type === 'Uint8' || type === 'Uint8C' || type === 'Uint16' || type === 'Uint32' || type === 'BigUint64') return true;
+  return false;
+}
+
+// TODO: IsUnclampedIntegerElementType
+
+/** https://tc39.es/ecma262/#sec-isbigintelementtype */
+export function IsBigIntElementType(type: TypedArrayTypes) {
+  if (type === 'BigUint64' || type === 'BigInt64') return true;
+  return false;
+}
+
+// TODO: IsNoTearConfiguration
+
+/** https://tc39.es/ecma262/#sec-rawbytestonumeric */
+export function RawBytesToNumeric(type: TypedArrayTypes, rawBytes: readonly number[], isLittleEndian: boolean) {
+  const elementSize = typedArrayInfoByType[type].ElementSize;
+  rawBytes = isLittleEndian ? rawBytes : rawBytes.toReversed();
+
+  if (type === 'Float16') {
+    return F(decodeFloat16(rawBytes));
+  }
+  if (type === 'Float32') {
+    return F(decodeFloat32(rawBytes));
+  }
+  if (type === 'Float64') {
+    return F(decodeFloat64(rawBytes));
+  }
+
+  // If IsUnsignedElementType(type) is true, then
+  //     Let intValue be the byte elements of rawBytes concatenated and interpreted as a bit string encoding of an unsigned little-endian binary number.
+  // Else,
+  //     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.
+  const isUnsigned = IsUnsignedElementType(type);
+  const bits = BigInt(elementSize * 8);
+  let intValue = 0n;
+  for (let i = 0; i < rawBytes.length; i += 1) {
+    intValue |= BigInt(rawBytes[i]!) << BigInt(i * 8);
+  }
+
+  if (!isUnsigned) {
+    const signBit = 1n << (bits - 1n);
+    if ((intValue & signBit) !== 0n) {
+      intValue -= 1n << bits;
+    }
+  }
+
+  return IsBigIntElementType(type) ? Z(intValue) : F(Number(intValue));
+}
+
+// TODO: GetRawBytesFromSharedBlock
+
+/** https://tc39.es/ecma262/#sec-getvaluefrombuffer */
+export function GetValueFromBuffer(arrayBuffer: ArrayBufferObject, byteIndex: number, type: TypedArrayTypes, _isTypedArray: boolean, _order: 'unordered', isLittleEndian?: boolean) {
+  // 1. Assert: IsDetachedBuffer(arrayBuffer) is false.
+  Assert(!IsDetachedBuffer(arrayBuffer));
+  // 2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
+  // 3. Assert: byteIndex is a non-negative integer.
+  Assert(isNonNegativeInteger(byteIndex));
+  // 4. Let block be arrayBuffer.[[ArrayBufferData]].
+  const block = arrayBuffer.ArrayBufferData!;
+  // 5. Let elementSize be the Element Size value specified in Table 61 for Element Type type.
+  const elementSize = typedArrayInfoByType[type].ElementSize;
+  // 6. If IsSharedArrayBuffer(arrayBuffer) is true, then
+  if (IsSharedArrayBuffer(arrayBuffer)) {
+    sharedArrayBufferNotSupported();
+  }
+  // 7. Else, let rawValue be a List of elementSize containing, in order, the elementSize sequence of bytes starting with block[byteIndex].
+  const rawValue = [...block.subarray(byteIndex, byteIndex + elementSize)];
+  // 8. If isLittleEndian is not present, set isLittleEndian to the value of the [[LittleEndian]] field of the surrounding agent's Agent Record.
+  if (isLittleEndian === undefined) {
+    const AR = surroundingAgent.AgentRecord;
+    isLittleEndian = AR.LittleEndian;
+  }
+  // 9. Return RawBytesToNumeric(type, rawValue, isLittleEndian).
+  return RawBytesToNumeric(type, rawValue, isLittleEndian);
+}
+
+/** https://tc39.es/ecma262/#sec-numerictorawbytes */
+export function NumericToRawBytes(type: TypedArrayTypes, value: NumberValue | BigIntValue, isLittleEndian: boolean) {
+  let rawBytes: number[];
+  if (type === 'Float16') {
+    rawBytes = encodeFloat16(Number(value.value));
+  } else if (type === 'Float32') {
+    rawBytes = encodeFloat32(Number(value.value));
+  } else if (type === 'Float64') {
+    rawBytes = encodeFloat64(Number(value.value));
+  } else {
+    const conversionOperation = typedArrayInfoByType[type].ConversionOperation as (argument: Value) => ValueEvaluator<NumberValue | BigIntValue>;
+    const intValue = R(X(conversionOperation(value)));
+    // If intValue ≥ 0, then
+    //     Let rawBytes be a List whose elements are the n-byte binary encoding of intValue. The bytes are ordered in little endian order.
+    // Else,
+    //     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.
+    const byteCount = typedArrayInfoByType[type].ElementSize;
+    const mod = 1n << BigInt(byteCount * 8);
+    let bits = typeof intValue === 'bigint' ? intValue : BigInt(intValue);
+    if (bits < 0) {
+      bits += mod;
+    }
+
+    const nextRawBytes = new Array<number>(byteCount);
+    for (let i = 0; i < byteCount; i += 1) {
+      nextRawBytes[i] = Number((bits >> BigInt(i * 8)) & 0xFFn);
+    }
+    rawBytes = nextRawBytes;
+  }
+  if (isLittleEndian) return rawBytes;
+  return rawBytes.toReversed();
+}
+
+/** https://tc39.es/ecma262/#sec-setvalueinbuffer */
+export function* SetValueInBuffer(arrayBuffer: ArrayBufferObject, byteIndex: number, type: TypedArrayTypes, value: BigIntValue | NumberValue, _isTypedArray: boolean, _order: 'seq-cst' | 'unordered' | 'init', isLittleEndian?: boolean): ValueEvaluator<UndefinedValue> {
+  // 1. Assert: IsDetachedBuffer(arrayBuffer) is false.
+  Assert(!IsDetachedBuffer(arrayBuffer));
+  // 2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
+  // 3. Assert: byteIndex is a non-negative integer.
+  Assert(isNonNegativeInteger(byteIndex));
+  // 4. Assert: Type(value) is BigInt if IsBigIntElementType(type) is true; otherwise, Type(value) is Number.
+  if (IsBigIntElementType(type)) {
+    Assert(value instanceof BigIntValue);
+  } else {
+    Assert(value instanceof NumberValue);
+  }
+  // 5. Let block be arrayBuffer.[[ArrayBufferData]].
+  const block = arrayBuffer.ArrayBufferData!;
+  // 6. Let elementSize be the Element Size value specified in Table 61 for Element Type type.
+  // const elementSize = typedArrayInfoByType[type].ElementSize;
+  // 7. If isLittleEndian is not present, set isLittleEndian to the value of the [[LittleEndian]] field of the surrounding agent's Agent Record.
+  if (isLittleEndian === undefined) {
+    const AR = surroundingAgent.AgentRecord;
+    isLittleEndian = AR.LittleEndian;
+  }
+  // 8. Let rawBytes be NumericToRawBytes(type, value, isLittleEndian).
+  const rawBytes = NumericToRawBytes(type, value, isLittleEndian);
+  // 9. If IsSharedArrayBuffer(arrayBuffer) is true, then
+  if (IsSharedArrayBuffer(arrayBuffer)) {
+    sharedArrayBufferNotSupported();
+  }
+  // 10. Else, store the individual bytes of rawBytes into block, in order, starting at block[byteIndex].
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(arrayBuffer));
+  rawBytes.forEach((byte, i) => {
+    block[byteIndex + i] = byte;
+  });
+  // 11. Return NormalCompletion(undefined).
+  return NormalCompletion(Value.undefined);
+}
+
+// TODO: GetModifySetValueInBuffer