@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

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

@@ -0,0 +1,316 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Descriptor,
+  ObjectValue,
+  JSStringValue,
+  Value,
+  wellKnownSymbols,
+  type ObjectInternalMethods,
+  NumberValue,
+  UndefinedValue,
+  BooleanValue,
+} from '../value.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import type { YieldEvaluator } from '../evaluator.mts';
+import { isTypedArrayObject } from '../intrinsics/TypedArray.mts';
+import {
+  AbstractRelationalComparison,
+  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,
+  MakeTypedArrayWithBufferWitnessRecord,
+  IsTypedArrayOutOfBounds,
+  TypedArrayLength,
+  CreateIteratorResultObject,
+  GeneratorYield,
+} from './all.mts';
+
+const InternalMethods = {
+  /** https://tc39.es/ecma262/#sec-array-exotic-objects-defineownproperty-p-desc */
+  DefineOwnProperty(P, Desc) {
+    const A = this;
+
+    Assert(IsPropertyKey(P));
+    if (P instanceof JSStringValue && P.stringValue() === 'length') {
+      return Q(ArraySetLength(A, Desc));
+    } else if (isArrayIndex(P)) {
+      let oldLenDesc = OrdinaryGetOwnProperty(A, Value('length')) as Descriptor;
+      Assert(X(IsDataDescriptor(oldLenDesc)));
+      Assert(oldLenDesc.Configurable === Value.false);
+      const oldLen = oldLenDesc.Value as NumberValue;
+      const index = X(ToUint32(P));
+      if (R(index) >= R(oldLen) && oldLenDesc.Writable === Value.false) {
+        return Value.false;
+      }
+      const succeeded = X(OrdinaryDefineOwnProperty(A, P, Desc));
+      if (succeeded === Value.false) {
+        return Value.false;
+      }
+      if (R(index) >= R(oldLen)) {
+        oldLenDesc = Descriptor({ ...oldLenDesc, Value: F(R(index) + 1) });
+        const succeeded = OrdinaryDefineOwnProperty(A, Value('length'), oldLenDesc); // eslint-disable-line no-shadow
+        Assert(succeeded === Value.true);
+      }
+      return Value.true;
+    }
+    return OrdinaryDefineOwnProperty(A, P, Desc);
+  },
+} satisfies Partial<ObjectInternalMethods<OrdinaryObject>>;
+
+export function isArrayExoticObject(O: ObjectValue) {
+  return O.DefineOwnProperty === InternalMethods.DefineOwnProperty;
+}
+
+/** https://tc39.es/ecma262/#sec-arraycreate */
+export function ArrayCreate(length: number, proto?: ObjectValue): ExpressionCompletion<OrdinaryObject> {
+  Assert(isNonNegativeInteger(length));
+  if (Object.is(length, -0)) {
+    length = +0;
+  }
+  if (length > (2 ** 32) - 1) {
+    return surroundingAgent.Throw('RangeError', 'InvalidArrayLength', length);
+  }
+  if (proto === undefined) {
+    proto = surroundingAgent.intrinsic('%Array.prototype%');
+  }
+  const A = X(MakeBasicObject(['Prototype', 'Extensible'])) as Mutable<OrdinaryObject>;
+  A.Prototype = proto;
+  A.DefineOwnProperty = InternalMethods.DefineOwnProperty;
+
+  X(OrdinaryDefineOwnProperty(A, Value('length'), Descriptor({
+    Value: F(length),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+
+  return A;
+}
+
+/** https://tc39.es/ecma262/#sec-arrayspeciescreate */
+export function ArraySpeciesCreate(originalArray: ObjectValue, length: number) {
+  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 C = Q(Get(originalArray, Value('constructor')));
+  if (IsConstructor(C) === Value.true) {
+    const thisRealm = surroundingAgent.currentRealmRecord;
+    const realmC = Q(GetFunctionRealm(C as FunctionObject));
+    if (thisRealm !== realmC) {
+      if (SameValue(C, realmC.Intrinsics['%Array%']) === Value.true) {
+        C = Value.undefined;
+      }
+    }
+  }
+  if (C instanceof ObjectValue) {
+    C = Q(Get(C, wellKnownSymbols.species));
+    if (C === Value.null) {
+      C = Value.undefined;
+    }
+  }
+  if (C === Value.undefined) {
+    return Q(ArrayCreate(length));
+  }
+  if (IsConstructor(C) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAConstructor', C);
+  }
+  return Q(Construct(C as FunctionObject, [F(length)]));
+}
+
+/** https://tc39.es/ecma262/#sec-arraysetlength */
+export function ArraySetLength(A: OrdinaryObject, Desc: Descriptor) {
+  if (Desc.Value === undefined) {
+    return OrdinaryDefineOwnProperty(A, Value('length'), Desc);
+  }
+  let newLenDesc = Desc;
+  const newLen = R(Q(ToUint32(Desc.Value)));
+  const numberLen = R(Q(ToNumber(Desc.Value)));
+  if (newLen !== numberLen) {
+    return surroundingAgent.Throw('RangeError', 'InvalidArrayLength', Desc.Value);
+  }
+  newLenDesc = Descriptor({ ...Desc, Value: F(newLen) });
+  const oldLenDesc = OrdinaryGetOwnProperty(A, Value('length')) as Descriptor;
+  Assert(X(IsDataDescriptor(oldLenDesc)));
+  Assert(oldLenDesc.Configurable === Value.false);
+  const oldLen = R(oldLenDesc.Value as NumberValue);
+  if (newLen >= oldLen) {
+    return OrdinaryDefineOwnProperty(A, 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(A, Value('length'), newLenDesc));
+  if (succeeded === Value.false) {
+    return Value.false;
+  }
+  const keys: JSStringValue[] = [];
+  A.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(A.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(A, Value('length'), newLenDesc));
+      return Value.false;
+    }
+  }
+  if (newWritable === false) {
+    const s = OrdinaryDefineOwnProperty(A, Value('length'), Descriptor({ Writable: Value.false }));
+    Assert(s === Value.true);
+  }
+  return Value.true;
+}
+
+/** https://tc39.es/ecma262/#sec-isconcatspreadable */
+export function IsConcatSpreadable(O: Value): ExpressionCompletion<BooleanValue> {
+  if (!(O instanceof ObjectValue)) {
+    return Value.false;
+  }
+  const spreadable = Q(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): ExpressionCompletion<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(ToNumber(Q(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(ToString(x));
+  // 6. Let yString be ? ToString(y).
+  const yString = Q(ToString(y));
+  // 7. Let xSmaller be the result of performing Abstract Relational Comparison xString < yString.
+  const xSmaller = AbstractRelationalComparison(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 = AbstractRelationalComparison(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'): ExpressionCompletion<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 = MakeTypedArrayWithBufferWitnessRecord(array, 'seq-cst');
+        if (IsTypedArrayOutOfBounds(taRecord)) {
+          return surroundingAgent.Throw('TypeError', 'TypedArrayOutOfBounds');
+        }
+        // 2. Let len be array.[[ArrayLength]].
+        len = TypedArrayLength(taRecord);
+      } else { // ii. Else,
+        // 1. Let len be ? LengthOfArrayLike(array).
+        len = Q(LengthOfArrayLike(array));
+      }
+      // iii. If index ≥ len, return undefined.
+      if (index >= len) {
+        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(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%).
+  return CreateIteratorFromClosure(closure, Value('%ArrayIteratorPrototype%'), surroundingAgent.intrinsic('%ArrayIteratorPrototype%'));
+}

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

@@ -0,0 +1,247 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  NumberValue, BigIntValue, BooleanValue, Value,
+  DataBlock,
+  UndefinedValue,
+  NullValue,
+} from '../value.mts';
+import {
+  Q, X, NormalCompletion, type ExpressionCompletion,
+} from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import { typedArrayInfoByType, type TypedArrayTypes } from '../intrinsics/TypedArray.mts';
+import {
+  Assert, OrdinaryCreateFromConstructor,
+  isNonNegativeInteger, CreateByteDataBlock,
+  SameValue, CopyDataBlockBytes,
+  F,
+  Z, R,
+  type FunctionObject,
+  type OrdinaryObject,
+} from './all.mts';
+
+export interface ArrayBufferObject extends OrdinaryObject {
+  readonly ArrayBufferData: DataBlock | NullValue;
+  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): ExpressionCompletion<ArrayBufferObject> {
+  const slots = ['ArrayBufferData', 'ArrayBufferByteLength', 'ArrayBufferDetachKey'];
+  let allocatingResizableBuffer;
+  if (maxByteLength !== undefined) {
+    allocatingResizableBuffer = true;
+  } else {
+    allocatingResizableBuffer = false;
+  }
+  if (allocatingResizableBuffer) {
+    if (byteLength > maxByteLength!) {
+      return surroundingAgent.Throw('RangeError', 'ResizableBufferInvalidMaxByteLength');
+    }
+    slots.push('ArrayBufferMaxByteLength');
+  }
+  const obj = Q(OrdinaryCreateFromConstructor(constructor, '%ArrayBuffer.prototype%', slots)) as Mutable<ArrayBufferObject>;
+  // 2. Assert: byteLength is a non-negative integer.
+  Assert(isNonNegativeInteger(byteLength));
+  // 3. Let block be ? CreateByteDataBlock(byteLength).
+  const block = Q(CreateByteDataBlock(byteLength));
+  // 4. Set obj.[[ArrayBufferData]] to block.
+  obj.ArrayBufferData = block;
+  // 5. Set obj.[[ArrayBufferByteLength]] to byteLength.
+  obj.ArrayBufferByteLength = byteLength;
+  // 6. Return obj.
+  if (allocatingResizableBuffer) {
+    (obj as Mutable<ResizableArrayBufferObject>).ArrayBufferMaxByteLength = maxByteLength!;
+  }
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-isdetachedbuffer */
+export function IsDetachedBuffer(arrayBuffer: ArrayBufferObject) {
+  if (arrayBuffer.ArrayBufferData === Value.null) {
+    return Value.true;
+  }
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-detacharraybuffer */
+export function DetachArrayBuffer(arrayBuffer: Mutable<ArrayBufferObject>, key?: Value) {
+  // 2. Assert: IsSharedArrayBuffer(arrayBuffer) is false.
+  Assert(IsSharedArrayBuffer(arrayBuffer) === Value.false);
+  // 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) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'BufferDetachKeyMismatch', key, arrayBuffer);
+  }
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(arrayBuffer));
+  // 5. Set arrayBuffer.[[ArrayBufferData]] to null.
+  arrayBuffer.ArrayBufferData = Value.null;
+  // 6. Set arrayBuffer.[[ArrayBufferByteLength]] to 0.
+  arrayBuffer.ArrayBufferByteLength = 0;
+  return undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-issharedarraybuffer */
+export function IsSharedArrayBuffer(_obj: Value): BooleanValue {
+  return Value.false;
+}
+
+export function CloneArrayBuffer(srcBuffer: ArrayBufferObject, srcByteOffset: number, srcLength: number): ExpressionCompletion<ArrayBufferObject> {
+  Assert(IsDetachedBuffer(srcBuffer) === Value.false);
+  const targetBuffer = Q(AllocateArrayBuffer(surroundingAgent.intrinsic('%ArrayBuffer%'), srcLength));
+  const srcBlock = srcBuffer.ArrayBufferData as DataBlock;
+  const targetBlock = targetBuffer.ArrayBufferData as DataBlock;
+  CopyDataBlockBytes(targetBlock, 0, srcBlock, srcByteOffset, srcLength);
+  return targetBuffer;
+}
+
+/** https://tc39.es/ecma262/#sec-isbigintelementtype */
+export function IsBigIntElementType(type: TypedArrayTypes) {
+  // 1. If type is BigUint64 or BigInt64, return true.
+  if (type === 'BigUint64' || type === 'BigInt64') {
+    return Value.true;
+  }
+  // 2. Return false
+  return Value.false;
+}
+
+const throwawayBuffer = new ArrayBuffer(8);
+const throwawayDataView = new DataView(throwawayBuffer);
+const throwawayArray = new Uint8Array(throwawayBuffer);
+
+/** https://tc39.es/ecma262/#sec-rawbytestonumeric */
+export function RawBytesToNumeric(type: TypedArrayTypes, rawBytes: number[], isLittleEndian: BooleanValue) {
+  // 1. Let elementSize be the Element Size value specified in Table 61 for Element Type type.
+  const elementSize = typedArrayInfoByType[type].ElementSize;
+  Assert(elementSize === rawBytes.length);
+  const dataViewType = type === 'Uint8C' ? 'Uint8' : type;
+  Object.assign(throwawayArray, rawBytes);
+  const result = throwawayDataView[`get${dataViewType}`](0, isLittleEndian === Value.true);
+  return IsBigIntElementType(type) === Value.true ? Z(result as bigint) : F(result as number);
+}
+
+/** https://tc39.es/ecma262/#sec-getvaluefrombuffer */
+export function GetValueFromBuffer(arrayBuffer: ArrayBufferObject, byteIndex: number, type: TypedArrayTypes, _isTypedArray: boolean, _order: 'unordered', isLittleEndian?: BooleanValue) {
+  // 1. Assert: IsDetachedBuffer(arrayBuffer) is false.
+  Assert(IsDetachedBuffer(arrayBuffer) === Value.false);
+  // 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 as DataBlock;
+  // 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) === Value.true) {
+    Assert(false);
+  }
+  // 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) {
+    isLittleEndian = surroundingAgent.AgentRecord.LittleEndian;
+  }
+  // 9. Return RawBytesToNumeric(type, rawValue, isLittleEndian).
+  return RawBytesToNumeric(type, rawValue, isLittleEndian);
+}
+
+const float32NaNLE = Object.freeze([0, 0, 192, 127]);
+const float32NaNBE = Object.freeze([127, 192, 0, 0]);
+const float64NaNLE = Object.freeze([0, 0, 0, 0, 0, 0, 248, 127]);
+const float64NaNBE = Object.freeze([127, 248, 0, 0, 0, 0, 0, 0]);
+
+/** https://tc39.es/ecma262/#sec-numerictorawbytes */
+export function NumericToRawBytes(type: TypedArrayTypes, value: NumberValue | BigIntValue, _isLittleEndian: BooleanValue) {
+  Assert(_isLittleEndian instanceof BooleanValue);
+  const isLittleEndian = _isLittleEndian === Value.true;
+  let rawBytes;
+  // One day, we will write our own IEEE 754 and two's complement encoder…
+  if (type === 'Float32') {
+    if (Number.isNaN(R(value))) {
+      rawBytes = isLittleEndian ? [...float32NaNLE] : [...float32NaNBE];
+    } else {
+      throwawayDataView.setFloat32(0, R(value as NumberValue), isLittleEndian);
+      rawBytes = [...throwawayArray.subarray(0, 4)];
+    }
+  } else if (type === 'Float64') {
+    if (Number.isNaN(R(value))) {
+      rawBytes = isLittleEndian ? [...float64NaNLE] : [...float64NaNBE];
+    } else {
+      throwawayDataView.setFloat64(0, R(value as NumberValue), isLittleEndian);
+      rawBytes = [...throwawayArray.subarray(0, 8)];
+    }
+  } else {
+    // a. Let n be the Element Size value specified in Table 61 for Element Type type.
+    const n = typedArrayInfoByType[type].ElementSize;
+    // b. Let convOp be the abstract operation named in the Conversion Operation column in Table 61 for Element Type type.
+    const convOp = typedArrayInfoByType[type].ConversionOperation;
+    // c. Let intValue be convOp(value) treated as a mathematical value, whether the result is a BigInt or Number.
+    const intValue = X(convOp(value));
+    const dataViewType = type === 'Uint8C' ? 'Uint8' : type;
+    throwawayDataView[`set${dataViewType}`](0, R(intValue) as bigint & number, isLittleEndian);
+    rawBytes = [...throwawayArray.subarray(0, n)];
+  }
+  return rawBytes;
+}
+
+/** https://tc39.es/ecma262/#sec-setvalueinbuffer */
+export function SetValueInBuffer(arrayBuffer: ArrayBufferObject, byteIndex: number, type: TypedArrayTypes, value: BigIntValue | NumberValue, _isTypedArray: unknown, _order: unknown, isLittleEndian?: BooleanValue): ExpressionCompletion<UndefinedValue> {
+  // 1. Assert: IsDetachedBuffer(arrayBuffer) is false.
+  Assert(IsDetachedBuffer(arrayBuffer) === Value.false);
+  // 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) === Value.true) {
+    Assert(value instanceof BigIntValue);
+  } else {
+    Assert(value instanceof NumberValue);
+  }
+  // 5. Let block be arrayBuffer.[[ArrayBufferData]].
+  const block = arrayBuffer.ArrayBufferData as DataBlock;
+  // 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) {
+    isLittleEndian = surroundingAgent.AgentRecord.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) === Value.true) {
+    Assert(false);
+  }
+  // 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);
+}
+
+/** https://tc39.es/ecma262/#sec-arraybufferbytelength */
+export function ArrayBufferByteLength(arrayBuffer: ArrayBufferObject, _order: 'seq-cst' | 'unordered'): number {
+  if (IsSharedArrayBuffer(arrayBuffer) === Value.true) {
+    Assert(false);
+  }
+  Assert(IsDetachedBuffer(arrayBuffer) === Value.false);
+  return arrayBuffer.ArrayBufferByteLength;
+}
+
+/** https://tc39.es/ecma262/#sec-isfixedlengtharraybuffer */
+export function IsFixedLengthArrayBuffer(arrayBuffer: ArrayBufferObject) {
+  return !('ArrayBufferMaxByteLength' in arrayBuffer);
+}

package/src/abstract-ops/async-function-operations.mts

@@ -0,0 +1,43 @@
+import { EnsureCompletion, X } from '../completion.mts';
+import { ExecutionContext, surroundingAgent } from '../engine.mts';
+import { Evaluate } from '../evaluator.mts';
+import { Value } from '../value.mts';
+import { resume } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { Assert, Call, PromiseCapabilityRecord } from './all.mts';
+
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-async-function-objects */
+
+/** https://tc39.es/ecma262/#sec-asyncblockstart */
+export function AsyncBlockStart(promiseCapability: PromiseCapabilityRecord, asyncBody: ParseNode.AsyncBody | ParseNode.ExpressionBody | ParseNode.Module, asyncContext: ExecutionContext) {
+  asyncContext.promiseCapability = promiseCapability;
+
+  const runningContext = surroundingAgent.runningExecutionContext;
+  asyncContext.codeEvaluationState = (function* resumer() {
+    const result = EnsureCompletion(yield* Evaluate(asyncBody));
+    // Assert: If we return here, the async function either threw an exception or performed an implicit or explicit return; all awaiting is done.
+    surroundingAgent.executionContextStack.pop(asyncContext);
+    if (result.Type === 'normal') {
+      X(Call(promiseCapability.Resolve, Value.undefined, [Value.undefined]));
+    } else if (result.Type === 'return') {
+      X(Call(promiseCapability.Resolve, Value.undefined, [result.Value]));
+    } else {
+      Assert(result.Type === 'throw');
+      X(Call(promiseCapability.Reject, Value.undefined, [result.Value]));
+    }
+    return Value.undefined;
+  }());
+  surroundingAgent.executionContextStack.push(asyncContext);
+  const result = EnsureCompletion(resume(asyncContext, Value.undefined));
+  Assert(surroundingAgent.runningExecutionContext === runningContext);
+  Assert(result.Type === 'normal' && result.Value === Value.undefined);
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-async-functions-abstract-operations-async-function-start */
+export function AsyncFunctionStart(promiseCapability: PromiseCapabilityRecord, asyncFunctionBody: ParseNode.AsyncBody | ParseNode.ExpressionBody) {
+  const runningContext = surroundingAgent.runningExecutionContext;
+  const asyncContext = runningContext.copy();
+  X(AsyncBlockStart(promiseCapability, asyncFunctionBody, asyncContext));
+}