@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

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

@@ -0,0 +1,246 @@
+import { typedArrayInfoByType, type TypedArrayTypes } from '../intrinsics/TypedArray.mts';
+import { IsGrowableSharedArrayBuffer, sharedArrayBufferNotSupported } from './shared-arraybuffer.mts';
+import {
+  surroundingAgent,
+  NumberValue, BigIntValue, BooleanValue, Value,
+  DataBlock,
+  UndefinedValue,
+  NullValue,
+  Q, X, NormalCompletion, type ValueEvaluator,
+  type Mutable,
+  Assert, OrdinaryCreateFromConstructor,
+  isNonNegativeInteger, CreateByteDataBlock,
+  SameValue, CopyDataBlockBytes,
+  F,
+  Z, R,
+  type FunctionObject,
+  type OrdinaryObject,
+} from '#self';
+
+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): ValueEvaluator<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(yield* 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 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) === 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) {
+  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 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));
+  // 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)) {
+    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);
+}
+
+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 as (argument: Value) => ValueEvaluator<NumberValue | BigIntValue>;
+    // 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: boolean, _order: 'seq-cst' | 'unordered' | 'init', isLittleEndian?: BooleanValue): 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) === 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) {
+    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);
+}
+
+/** 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-isfixedlengtharraybuffer */
+export function IsFixedLengthArrayBuffer(arrayBuffer: ArrayBufferObject) {
+  return !('ArrayBufferMaxByteLength' in arrayBuffer);
+}

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

@@ -0,0 +1,46 @@
+import { resume } from '../helpers.mts';
+import {
+  EnsureCompletion, X, ExecutionContext, surroundingAgent, Evaluate, Value, type ParseNode, Assert, Call, PromiseCapabilityRecord,
+  type AsyncBuiltinSteps,
+} from '#self';
+
+// 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 | AsyncBuiltinSteps, asyncContext: ExecutionContext) {
+  asyncContext.promiseCapability = promiseCapability;
+
+  const runningContext = surroundingAgent.runningExecutionContext;
+  asyncContext.codeEvaluationState = (function* resumer() {
+    let result;
+    if (typeof asyncBody === 'function') {
+      result = EnsureCompletion(yield* asyncBody());
+    } else {
+      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(yield* resume(asyncContext, { type: 'await-resume', value: 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 | AsyncBuiltinSteps) {
+  const runningContext = surroundingAgent.runningExecutionContext;
+  const asyncContext = runningContext.copy();
+  X(yield* AsyncBlockStart(promiseCapability, asyncFunctionBody, asyncContext));
+}

package/src/abstract-ops/async-generator-objects.mts

@@ -0,0 +1,346 @@
+import { ExecutionContext, surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Q, X,
+  Await,
+  EnsureCompletion,
+  NormalCompletion,
+  AbruptCompletion,
+  ThrowCompletion,
+  type YieldCompletion,
+  ReturnCompletion,
+} from '../completion.mts';
+import { Evaluate, type PlainEvaluator, type YieldEvaluator } from '../evaluator.mts';
+import {
+  BooleanValue, JSStringValue, Value, type Arguments,
+  type NativeSteps,
+} from '../value.mts';
+import {
+  resume, __ts_cast__,
+} from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Assert,
+  Call,
+  CreateBuiltinFunction,
+  CreateIteratorResultObject,
+  generatorBrandToErrorMessageType,
+  GetGeneratorKind,
+  PerformPromiseThen,
+  PromiseCapabilityRecord,
+  PromiseResolve,
+  Realm,
+  RequireInternalSlot,
+  SameValue,
+  type OrdinaryObject,
+} from './all.mts';
+
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-asyncgenerator-objects */
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorrequest-records */
+class AsyncGeneratorRequestRecord {
+  Completion: YieldCompletion;
+
+  Capability: PromiseCapabilityRecord;
+
+  constructor(completion: YieldCompletion, promiseCapability: PromiseCapabilityRecord) {
+    this.Completion = completion;
+    this.Capability = promiseCapability;
+  }
+}
+
+export interface AsyncGeneratorObject extends OrdinaryObject {
+  AsyncGeneratorState: 'suspendedStart' | 'suspendedYield' | 'executing' | 'completed' | 'draining-queue';
+  AsyncGeneratorContext: ExecutionContext;
+  AsyncGeneratorQueue: AsyncGeneratorRequestRecord[];
+  GeneratorBrand: JSStringValue | undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorstart */
+export function AsyncGeneratorStart(generator: AsyncGeneratorObject, generatorBody: ParseNode.AsyncGeneratorBody | (() => YieldEvaluator)) {
+  // 1. Assert: generator.[[AsyncGeneratorState]] is 'suspendedStart'.
+  Assert(generator.AsyncGeneratorState === 'suspendedStart');
+  // 2. Let genContext be the running execution context.
+  const genContext = surroundingAgent.runningExecutionContext;
+  // 3. Set the Generator component of genContext to generator.
+  genContext.Generator = generator;
+  const closure = function* resumer(): YieldEvaluator {
+    const acGenContext = surroundingAgent.runningExecutionContext;
+    const acGenerator = acGenContext.Generator as AsyncGeneratorObject;
+    // a. If generatorBody is a Parse Node, then
+    //     i. Let result be the result of evaluating generatorBody.
+    // b. Else,
+    //     i. Assert: generatorBody is an Abstract Closure.
+    //     ii. Let result be generatorBody().
+    let result = EnsureCompletion(
+      // Note: Engine262 can only perform the "If generatorBody is an Abstract Closure" check:
+      yield* typeof generatorBody === 'function'
+        ? generatorBody()
+        : Evaluate(generatorBody),
+    ) as YieldCompletion;
+    // c. Assert: If we return here, the async generator either threw an exception or performed either an implicit or explicit return.
+    // d. Remove genContext from the execution context stack and restore the execution context
+    //    that is at the top of the execution context stack as the running execution context.
+    surroundingAgent.executionContextStack.pop(acGenContext);
+    // e. Set generator.[[AsyncGeneratorState]] to completed.
+    acGenerator.AsyncGeneratorState = 'draining-queue';
+    // f. If result.[[Type]] is normal, set result to NormalCompletion(undefined).
+    if (result instanceof NormalCompletion) {
+      result = NormalCompletion(Value.undefined);
+    }
+    // g. If result.[[Type]] is return, set result to NormalCompletion(result.[[Value]]).
+    if (result instanceof ReturnCompletion) {
+      result = NormalCompletion(result.Value);
+    }
+    // h. Perform AsyncGeneratorCompleteStep(generator, result, true).
+    AsyncGeneratorCompleteStep(acGenerator, result, Value.true);
+    // i. Perform AsyncGeneratorDrainQueue(generator).
+    yield* AsyncGeneratorDrainQueue(acGenerator);
+    // j. Return undefined.
+    return Value.undefined;
+  };
+  // 4. Set the code evaluation state of genContext such that when evaluation
+  //    is resumed for that execution context the following steps will be performed:
+  genContext.codeEvaluationState = (closure());
+  // 5. Set generator.[[AsyncGeneratorContext]] to genContext.
+  generator.AsyncGeneratorContext = genContext;
+  // 7. Set generator.[[AsyncGeneratorQueue]] to a new empty List.
+  generator.AsyncGeneratorQueue = [];
+  // 8. Return undefined.
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorvalidate */
+export function AsyncGeneratorValidate(generator: Value, generatorBrand: JSStringValue | undefined) {
+  // 1. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorContext]]).
+  Q(RequireInternalSlot(generator, 'AsyncGeneratorContext'));
+  // 2. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorState]]).
+  Q(RequireInternalSlot(generator, 'AsyncGeneratorState'));
+  // 3. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorQueue]]).
+  Q(RequireInternalSlot(generator, 'AsyncGeneratorQueue'));
+  __ts_cast__<AsyncGeneratorObject>(generator);
+  // 4. If generator.[[GeneratorBrand]] is not the same value as generatorBrand, throw a TypeError exception.
+  const brand = generator.GeneratorBrand;
+  if (
+    brand === undefined || generatorBrand === undefined
+      ? brand !== generatorBrand
+      : SameValue(brand, generatorBrand) === Value.false
+  ) {
+    return surroundingAgent.Throw(
+      'TypeError',
+      'NotATypeObject',
+      generatorBrandToErrorMessageType(generatorBrand) || 'AsyncGenerator',
+      generator,
+    );
+  }
+  return undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorenqueue */
+export function AsyncGeneratorEnqueue(generator: AsyncGeneratorObject, completion: YieldCompletion, promiseCapability: PromiseCapabilityRecord) {
+  // 1. Let request be AsyncGeneratorRequest { [[Completion]]: completion, [[Capability]]: promiseCapability }.
+  const request = new AsyncGeneratorRequestRecord(completion, promiseCapability);
+  // 2. Append request to the end of generator.[[AsyncGeneratorQueue]].
+  generator.AsyncGeneratorQueue.push(request);
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorcompletestep */
+function AsyncGeneratorCompleteStep(generator: AsyncGeneratorObject, completion: YieldCompletion, done: BooleanValue, realm?: Realm) {
+  // 1. Let queue be generator.[[AsyncGeneratorQueue]].
+  const queue = generator.AsyncGeneratorQueue;
+  // 2. Assert: queue is not empty.
+  Assert(queue.length > 0);
+  // 3. Let next be the first element of queue.
+  // 4. Remove the first element from queue.
+  const next = queue.shift()!;
+  // 5. Let promiseCapability be next.[[Capability]].
+  const promiseCapability = next.Capability;
+  // 6. Let value be completion.[[Value]].
+  const value = completion.Value;
+  // 7. If completion.[[Type]] is throw, then
+  if (completion instanceof ThrowCompletion) {
+    // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « value »).
+    X(Call(promiseCapability.Reject, Value.undefined, [value]));
+  } else { // 8. Else,
+    // a. Assert: completion.[[Type]] is normal.
+    Assert(completion instanceof NormalCompletion);
+    let iteratorResult;
+    // b. If realm is present, then
+    if (realm !== undefined) {
+      // i. Let oldRealm be the running execution context's Realm.
+      const oldRealm = surroundingAgent.runningExecutionContext.Realm;
+      // ii. Set the running execution context's Realm to realm.
+      surroundingAgent.runningExecutionContext.Realm = realm;
+      // iii. Let iteratorResult be CreateIteratorResultObject(value, done).
+      iteratorResult = CreateIteratorResultObject(value, done);
+      // iv. Set the running execution context's Realm to oldRealm.
+      surroundingAgent.runningExecutionContext.Realm = oldRealm;
+    } else { // c. Else,
+      // i. Let iteratorResult be CreateIteratorResultObject(value, done).
+      iteratorResult = CreateIteratorResultObject(value, done);
+    }
+    // d. Perform ! Call(promiseCapability.[[Resolve]], undefined, « iteratorResult »).
+    X(Call(promiseCapability.Resolve, Value.undefined, [iteratorResult]));
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorresume */
+export function* AsyncGeneratorResume(generator: AsyncGeneratorObject, completion: YieldCompletion) {
+  // 1. Assert: generator.[[AsyncGeneratorState]] is either suspendedStart or suspendedYield.
+  Assert(generator.AsyncGeneratorState === 'suspendedStart' || generator.AsyncGeneratorState === 'suspendedYield');
+  // 2. Let genContext be generator.[[AsyncGeneratorContext]].
+  const genContext = generator.AsyncGeneratorContext;
+  // 3. Let callerContext be the running execution context.
+  const callerContext = surroundingAgent.runningExecutionContext;
+  // 4. Suspend callerContext.
+  // 5. Set generator.[[AsyncGeneratorState]] to executing.
+  generator.AsyncGeneratorState = 'executing';
+  // 6. Push genContext onto the execution context stack; genContext is now the running execution context.
+  surroundingAgent.executionContextStack.push(genContext);
+  // 7. Resume the suspended evaluation of genContext using completion as the result of the operation that suspended it. Let result be the completion record returned by the resumed computation.
+  const result = yield* resume(genContext, { type: 'async-generator-resume', value: completion });
+  // 8. Assert: result is never an abrupt completion.
+  Assert(!(result instanceof AbruptCompletion));
+  // 9. Assert: When we return here, genContext has already been removed from the execution context stack and callerContext is the currently running execution context.
+  Assert(surroundingAgent.runningExecutionContext === callerContext);
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorunwrapyieldresumption */
+function* AsyncGeneratorUnwrapYieldResumption(resumptionValue: YieldCompletion): YieldEvaluator {
+  // 1. If resumptionValue.[[Type]] is not return, return Completion(resumptionValue).
+  if (!(resumptionValue instanceof ReturnCompletion)) {
+    return Q(resumptionValue);
+  }
+  // 2. Let awaited be Await(resumptionValue.[[Value]]).
+  const awaited = EnsureCompletion(yield* Await(resumptionValue.Value));
+  // 3. If awaited.[[Type]] is throw, return Completion(awaited).
+  if (awaited instanceof ThrowCompletion) {
+    return Q(awaited);
+  }
+  // 4. Assert: awaited.[[Type]] is normal.
+  Assert(awaited instanceof NormalCompletion);
+  // 5. Return Completion { [[Type]]: return, [[Value]]: awaited.[[Value]], [[Target]]: empty }.
+  return ReturnCompletion(awaited.Value);
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratoryield */
+export function* AsyncGeneratorYield(value: Value): YieldEvaluator {
+  // 1. Let genContext be the running execution context.
+  const genContext = surroundingAgent.runningExecutionContext;
+  // 2. Assert: genContext is the execution context of a generator.
+  Assert(!!genContext.Generator);
+  // 3. Let generator be the value of the Generator component of genContext.
+  const generator = genContext.Generator as AsyncGeneratorObject;
+  // 4. Assert: GetGeneratorKind() is async.
+  Assert(GetGeneratorKind() === 'async');
+  // 5. Let completion be NormalCompletion(value).
+  const completion = NormalCompletion(value);
+  // 6. Assert: The execution context stack has at least two elements.
+  Assert(surroundingAgent.executionContextStack.length >= 2);
+  // 7. Let previousContext be the second to top element of the execution context stack.
+  const previousContext = surroundingAgent.executionContextStack[surroundingAgent.executionContextStack.length - 2];
+  // 8. Let previousRealm be previousContext's Realm.
+  const previousRealm = previousContext.Realm;
+  // 9. Perform AsyncGeneratorCompleteStep(generator, completion, false, previousRealm).
+  AsyncGeneratorCompleteStep(generator, completion, Value.false, previousRealm);
+  // 10. Let queue be generator.[[AsyncGeneratorQueue]].
+  const queue = generator.AsyncGeneratorQueue;
+  // 11. If queue is not empty, then
+  if (queue.length > 0) {
+    // a. NOTE: Execution continues without suspending the generator.
+    // b. Let toYield be the first element of queue.
+    const toYield = queue[0];
+    // c. Let resumptionValue be toYield.[[Completion]].
+    const resumptionValue = toYield.Completion;
+    // d. Return AsyncGeneratorUnwrapYieldResumption(resumptionValue).
+    return yield* AsyncGeneratorUnwrapYieldResumption(resumptionValue);
+  } else { // 12. Else,
+    // a. Set generator.[[AsyncGeneratorState]] to suspendedYield.
+    generator.AsyncGeneratorState = 'suspendedYield';
+    // b. Remove genContext from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
+    surroundingAgent.executionContextStack.pop(genContext);
+    // c. Set the code evaluation state of genContext such that when evaluation is resumed with a Completion resumptionValue the following steps will be performed:
+    const resumptionValue = yield { type: 'async-generator-yield' };
+    Assert(resumptionValue.type === 'async-generator-resume');
+    // i. Return AsyncGeneratorUnwrapYieldResumption(resumptionValue).
+    return yield* AsyncGeneratorUnwrapYieldResumption(EnsureCompletion(resumptionValue.value));
+    // ii. NOTE: When the above step returns, it returns to the evaluation of the YieldExpression production that originally called this abstract operation.
+
+    // d. Return undefined.
+    // e. NOTE: This returns to the evaluation of the operation that had most previously resumed evaluation of genContext.
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorawaitreturn */
+export function* AsyncGeneratorAwaitReturn(generator: AsyncGeneratorObject): PlainEvaluator {
+  Assert(generator.AsyncGeneratorState === 'draining-queue');
+  // 1. Let queue be generator.[[AsyncGeneratorQueue]].
+  const queue = generator.AsyncGeneratorQueue;
+  // 2. Assert: queue is not empty.
+  Assert(queue.length > 0);
+  // 3. Let next be the first element of queue.
+  const next = queue[0];
+  // 4. Let completion be next.[[Completion]].
+  const completion = next.Completion;
+  // 5. Assert: completion.[[Type]] is return.
+  Assert(completion instanceof ReturnCompletion);
+  // 6. Let promise be PromiseResolve(%Promise%, completion.[[Value]]).
+  const promiseCompletion = yield* PromiseResolve(surroundingAgent.intrinsic('%Promise%'), completion.Value);
+  if (promiseCompletion instanceof AbruptCompletion) {
+    AsyncGeneratorCompleteStep(generator, promiseCompletion, Value.true);
+    yield* AsyncGeneratorDrainQueue(generator);
+    return;
+  }
+  const promise = X(promiseCompletion);
+  // 7. Let fulfilledClosure be a new Abstract Closure with parameters (value) that captures generator and performs the following steps when called:
+  const fulfilledClosure: NativeSteps = function* fulfilledClosure([value = Value.undefined]: Arguments) {
+    Assert(generator.AsyncGeneratorState === 'draining-queue');
+    // b. Let result be NormalCompletion(value).
+    const result = NormalCompletion(value);
+    // c. Perform AsyncGeneratorCompleteStep(generator, result, true).
+    AsyncGeneratorCompleteStep(generator, result, Value.true);
+    // d. Perform AsyncGeneratorDrainQueue(generator).
+    yield* AsyncGeneratorDrainQueue(generator);
+    // e. Return undefined.
+    return Value.undefined;
+  };
+  // 8. Let onFulfilled be CreateBuiltinFunction(fulfilledClosure, 1, "", « »).
+  const onFulfilled = CreateBuiltinFunction(fulfilledClosure, 1, Value(''), []);
+  // 9. Let rejectedClosure be a new Abstract Closure with parameters (reason) that captures generator and performs the following steps when called:
+  const rejectedClosure: NativeSteps = function* rejectedClosure([reason = Value.undefined]: Arguments) {
+    Assert(generator.AsyncGeneratorState === 'draining-queue');
+    // b. Let result be ThrowCompletion(reason).
+    const result = ThrowCompletion(reason);
+    // c. Perform AsyncGeneratorCompleteStep(generator, result, true).
+    AsyncGeneratorCompleteStep(generator, result, Value.true);
+    // d. Perform AsyncGeneratorDrainQueue(generator).
+    yield* AsyncGeneratorDrainQueue(generator);
+    // e. Return undefined.
+    return Value.undefined;
+  };
+  // 10. Let onRejected be CreateBuiltinFunction(rejectedClosure, 1, "", « »).
+  const onRejected = CreateBuiltinFunction(rejectedClosure, 1, Value(''), []);
+  // 11. Perform PerformPromiseThen(promise, onFulfilled, onRejected).
+  PerformPromiseThen(promise, onFulfilled, onRejected);
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratordrainqueue */
+function* AsyncGeneratorDrainQueue(generator: AsyncGeneratorObject) {
+  // 1. Assert: generator.[[AsyncGeneratorState]] is completed.
+  Assert(generator.AsyncGeneratorState === 'draining-queue');
+  // 2. Let queue be generator.[[AsyncGeneratorQueue]].
+  const queue = generator.AsyncGeneratorQueue;
+  while (queue.length) {
+    const next = queue[0];
+    let completion = next.Completion;
+    if (completion instanceof ReturnCompletion) {
+      yield* AsyncGeneratorAwaitReturn(generator);
+      return;
+    } else {
+      if (completion instanceof NormalCompletion) {
+        completion = NormalCompletion(Value.undefined);
+      }
+      AsyncGeneratorCompleteStep(generator, completion, Value.true);
+    }
+  }
+  generator.AsyncGeneratorState = 'completed';
+}