@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/AsyncDisposableStackPrototype.mts

@@ -0,0 +1,103 @@
+import { Descriptor, Value, wellKnownSymbols, type Arguments, type FunctionCallContext } from '../value.mts';
+import { NormalCompletion, Q, X, type ValueCompletion } from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import { AddDisposableResource, DisposeResources } from '../abstract-ops/disposable-operations.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { AsyncDisposableStackObject } from './AsyncDisposableStack.mts';
+import {
+  Call,
+  CreateBuiltinFunction,
+  IsCallable,
+  OrdinaryCreateFromConstructor,
+  Realm,
+  RequireInternalSlot,
+  surroundingAgent,
+  Throw,
+  type ValueEvaluator,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-asyncdisposablestack.prototype.adopt */
+function* AsyncDisposableStackProto_adopt(
+  [value = Value.undefined, onDisposeAsync = Value.undefined]: Arguments,
+  { thisValue }: FunctionCallContext,
+) {
+  Q(RequireInternalSlot(thisValue, 'AsyncDisposableState'));
+  const asyncDisposableStack = thisValue as AsyncDisposableStackObject;
+  if (asyncDisposableStack.AsyncDisposableState === 'disposed') return Throw.ReferenceError('Object is disposed');
+  if (!IsCallable(onDisposeAsync)) return Throw.TypeError('$1 is not a function', onDisposeAsync);
+  const closure = function* closure(): ValueEvaluator {
+    return Q(yield* Call(onDisposeAsync, Value.undefined, [value]));
+  };
+  const func = CreateBuiltinFunction(closure, 0, Value(''), []);
+  Q(yield* AddDisposableResource(asyncDisposableStack.DisposableResourceStack, Value.undefined, 'async-dispose', func));
+  return value;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncdisposablestack.prototype.defer */
+function* AsyncDisposableStackProto_defer(
+  [onDisposeAsync = Value.undefined]: Arguments,
+  { thisValue }: FunctionCallContext,
+) {
+  Q(RequireInternalSlot(thisValue, 'AsyncDisposableState'));
+  const asyncDisposableStack = thisValue as AsyncDisposableStackObject;
+  if (asyncDisposableStack.AsyncDisposableState === 'disposed') return Throw.ReferenceError('Object is disposed');
+  if (!IsCallable(onDisposeAsync)) return Throw.TypeError('$1 is not a function', onDisposeAsync);
+  Q(yield* AddDisposableResource(asyncDisposableStack.DisposableResourceStack, Value.undefined, 'async-dispose', onDisposeAsync));
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncdisposablestack.prototype.disposeAsync */
+function* AsyncDisposableStackProto_disposeAsync(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  Q(RequireInternalSlot(thisValue, 'AsyncDisposableState'));
+  const asyncDisposableStack = thisValue as AsyncDisposableStackObject;
+  if (asyncDisposableStack.AsyncDisposableState === 'disposed') return Value.undefined;
+  asyncDisposableStack.AsyncDisposableState = 'disposed';
+  return Q(yield* DisposeResources(asyncDisposableStack.DisposableResourceStack, NormalCompletion(Value.undefined)));
+}
+
+/** https://tc39.es/ecma262/#sec-get-asyncdisposablestack.prototype.disposed */
+function AsyncDisposableStackProto_disposed(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  Q(RequireInternalSlot(thisValue, 'AsyncDisposableState'));
+  const asyncDisposableStack = thisValue as AsyncDisposableStackObject;
+  if (asyncDisposableStack.AsyncDisposableState === 'disposed') return Value.true;
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncdisposablestack.prototype.move */
+function* AsyncDisposableStackProto_move(_args: Arguments, { thisValue }: FunctionCallContext) {
+  Q(RequireInternalSlot(thisValue, 'AsyncDisposableState'));
+  const asyncDisposableStack = thisValue as AsyncDisposableStackObject;
+  if (asyncDisposableStack.AsyncDisposableState === 'disposed') return Throw.ReferenceError('Object is disposed');
+  const newStack = Q(yield* OrdinaryCreateFromConstructor(
+    surroundingAgent.intrinsic('%AsyncDisposableStack%'),
+    '%AsyncDisposableStack.prototype%',
+    ['AsyncDisposableState', 'DisposableResourceStack'],
+  )) as Mutable<AsyncDisposableStackObject>;
+  newStack.AsyncDisposableState = 'pending';
+  newStack.DisposableResourceStack = asyncDisposableStack.DisposableResourceStack;
+  asyncDisposableStack.DisposableResourceStack = [];
+  asyncDisposableStack.AsyncDisposableState = 'disposed';
+  return newStack;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncdisposablestack.prototype.use */
+function* AsyncDisposableStackProto_use([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  Q(RequireInternalSlot(thisValue, 'AsyncDisposableState'));
+  const asyncDisposableStack = thisValue as AsyncDisposableStackObject;
+  if (asyncDisposableStack.AsyncDisposableState === 'disposed') return Throw.ReferenceError('Object is disposed');
+  Q(yield* AddDisposableResource(asyncDisposableStack.DisposableResourceStack, value, 'async-dispose'));
+  return value;
+}
+
+export function bootstrapAsyncDisposableStackPrototype(realmRec: Realm) {
+  const prototype = bootstrapPrototype(realmRec, [
+    ['adopt', AsyncDisposableStackProto_adopt, 2],
+    ['defer', AsyncDisposableStackProto_defer, 1],
+    ['disposeAsync', AsyncDisposableStackProto_disposeAsync, 0, undefined, true],
+    ['disposed', [AsyncDisposableStackProto_disposed]],
+    ['move', AsyncDisposableStackProto_move, 0],
+    ['use', AsyncDisposableStackProto_use, 1],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'AsyncDisposableStack');
+  X(prototype.DefineOwnProperty(wellKnownSymbols.asyncDispose, X(prototype.GetOwnProperty(Value('disposeAsync'))) as Descriptor));
+  realmRec.Intrinsics['%AsyncDisposableStack.prototype%'] = prototype;
+}

package/src/intrinsics/AsyncFromSyncIteratorPrototype.mts

@@ -0,0 +1,165 @@
+import {
+  ObjectValue, UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import {
+  IfAbruptRejectPromise, NormalCompletion, X,
+} from '../completion.mts';
+import { __ts_cast__ } from '../utils/language.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import {
+  AsyncFromSyncIteratorContinuation,
+  Call,
+  CreateIteratorResultObject,
+  GetMethod,
+  IteratorNext,
+  NewPromiseCapability,
+  Assert,
+  type OrdinaryObject,
+  type IteratorRecord,
+  IteratorClose,
+  type FunctionObject,
+  Realm,
+  Throw,
+} from '#self';
+
+export interface AsyncFromSyncIteratorObject extends OrdinaryObject {
+  readonly SyncIteratorRecord: IteratorRecord;
+}
+/** https://tc39.es/ecma262/#sec-%asyncfromsynciteratorprototype%.next */
+function* AsyncFromSyncIteratorPrototype_next([value]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let O be the this value.
+  const O = thisValue as AsyncFromSyncIteratorObject;
+  // 2. Assert: Type(O) is Object and O has a [[SyncIteratorRecord]] internal slot.
+  Assert(O instanceof ObjectValue && 'SyncIteratorRecord' in O);
+  // 3. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 4. Let syncIteratorRecord be O.[[SyncIteratorRecord]].
+  const syncIteratorRecord = O.SyncIteratorRecord;
+  // 5. If value is present, then
+  let result;
+  if (value !== undefined) {
+    // a. Let result be IteratorNext(syncIteratorRecord, value).
+    result = yield* IteratorNext(syncIteratorRecord, value);
+  } else { // 6. Else,
+    // a. Let result be IteratorNext(syncIteratorRecord).
+    result = yield* IteratorNext(syncIteratorRecord);
+  }
+  // 7. IfAbruptRejectPromise(result, promiseCapability).
+  IfAbruptRejectPromise(result, promiseCapability);
+  __ts_cast__<ObjectValue>(result);
+  // 8. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true).
+  return X(AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, Value.true));
+}
+
+/** https://tc39.es/ecma262/#sec-%asyncfromsynciteratorprototype%.return */
+function* AsyncFromSyncIteratorPrototype_return([value]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let O be the this value.
+  const O = thisValue as AsyncFromSyncIteratorObject;
+  // 2. Assert: Type(O) is Object and O has a [[SyncIteratorRecord]] internal slot.
+  Assert(O instanceof ObjectValue && 'SyncIteratorRecord' in O);
+  // 3. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 4. Let syncIterator be O.[[SyncIteratorRecord]].[[Iterator]].
+  const syncIteratorRecord = O.SyncIteratorRecord;
+  const syncIterator = syncIteratorRecord.Iterator;
+  // 5. Let return be GetMethod(syncIterator, "return").
+  const ret = yield* GetMethod(syncIterator, Value('return'));
+  // 6. IfAbruptRejectPromise(return, promiseCapability).
+  IfAbruptRejectPromise(ret, promiseCapability);
+  __ts_cast__<UndefinedValue | FunctionObject>(ret);
+  // 7. If return is undefined, then
+  if (ret === Value.undefined) {
+    // a. Let iteratorResult be CreateIteratorResultObject(value, true).
+    const iteratorResult = CreateIteratorResultObject(value || Value.undefined, Value.true);
+    // b. Perform ! Call(promiseCapability.[[Resolve]], undefined, « iteratorResult »).
+    X(Call(promiseCapability.Resolve, Value.undefined, [iteratorResult]));
+    // c. Return promiseCapability.[[Promise]].
+    return promiseCapability.Promise;
+  }
+  // 8. If value is present, then
+  let result;
+  if (value !== undefined) {
+    // a. Let result be Call(return, syncIterator, « value »).
+    result = yield* Call(ret, syncIterator, [value]);
+  } else { // 9. Else,
+    // a. Let result be Call(return, syncIterator).
+    result = yield* Call(ret, syncIterator);
+  }
+  // 10. IfAbruptRejectPromise(result, promiseCapability).
+  IfAbruptRejectPromise(result, promiseCapability);
+  __ts_cast__<Value>(result);
+  // 11. If result is not an Object, then
+  if (!(result instanceof ObjectValue)) {
+    // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
+    X(Call(promiseCapability.Reject, Value.undefined, [
+      Throw.TypeError('$1 is not an object', result).Value,
+    ]));
+    // b. Return promiseCapability.[[Promise]].
+    return promiseCapability.Promise;
+  }
+  // 12. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, false).
+  return X(AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, Value.false));
+}
+
+/** https://tc39.es/ecma262/#sec-%asyncfromsynciteratorprototype%.throw */
+function* AsyncFromSyncIteratorPrototype_throw([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let O be this value.
+  const O = thisValue as AsyncFromSyncIteratorObject;
+  // 2. Assert: Type(O) is Object and O has a [[SyncIteratorRecord]] internal slot.
+  Assert(O instanceof ObjectValue && 'SyncIteratorRecord' in O);
+  // 3. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 4. Let syncIterator be O.[[SyncIteratorRecord]].[[Iterator]].
+  const syncIteratorRecord = O.SyncIteratorRecord;
+  const syncIterator = syncIteratorRecord.Iterator;
+  // 5. Let throw be GetMethod(syncIterator, "throw").
+  const thr = yield* GetMethod(syncIterator, Value('throw'));
+  // 6. IfAbruptRejectPromise(throw, promiseCapability).
+  IfAbruptRejectPromise(thr, promiseCapability);
+  __ts_cast__<UndefinedValue | FunctionObject>(thr);
+  // 7. If throw is undefined, then
+  if (thr === Value.undefined) {
+    const closeCompletion = NormalCompletion(undefined);
+    const result = yield* IteratorClose(syncIteratorRecord, closeCompletion);
+    IfAbruptRejectPromise(result, promiseCapability);
+    X(Call(promiseCapability.Reject, Value.undefined, [
+      // TODO: error message should be no throw method
+      Throw.TypeError('$1 is not an object', value).Value,
+    ]));
+    return promiseCapability.Promise;
+  }
+  // 8. If value is present, then
+  let result;
+  if (value !== undefined) {
+    // a. Let result be Call(throw, syncIterator, « value »).
+    result = yield* Call(thr, syncIterator, [value]);
+  } else { // 9. Else,
+    // a. Let result be Call(throw, syncIterator).
+    result = yield* Call(thr, syncIterator);
+  }
+  // 10. IfAbruptRejectPromise(result, promiseCapability).
+  IfAbruptRejectPromise(result, promiseCapability);
+  __ts_cast__<Value>(result);
+  // 11. If Type(result) is not Object, then
+  if (!(result instanceof ObjectValue)) {
+    // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
+    X(Call(promiseCapability.Reject, Value.undefined, [
+      Throw.TypeError('$1 is not an object', result).Value,
+    ]));
+    // b. Return promiseCapability.[[Promise]].
+    return promiseCapability.Promise;
+  }
+  // 12. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true).
+  return X(AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, Value.true));
+}
+
+export function bootstrapAsyncFromSyncIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', AsyncFromSyncIteratorPrototype_next, 0],
+    ['return', AsyncFromSyncIteratorPrototype_return, 0],
+    ['throw', AsyncFromSyncIteratorPrototype_throw, 0],
+  ], realmRec.Intrinsics['%AsyncIteratorPrototype%']);
+
+  realmRec.Intrinsics['%AsyncFromSyncIteratorPrototype%'] = proto;
+}

package/src/intrinsics/AsyncFunction.mts

@@ -0,0 +1,33 @@
+import { Q, X } from '../completion.mts';
+import { CreateDynamicFunction } from '../runtime-semantics/all.mts';
+import { Descriptor, Value } from '../value.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import type {
+  Arguments, ValueEvaluator, FunctionCallContext, FunctionObject, Realm,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-async-function-constructor-arguments */
+function* AsyncFunctionConstructor(args: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  const bodyArg = args[args.length - 1] || Value('');
+  args = args.slice(0, -1) as Arguments;
+  // 1. Let C be the active function object.
+  const activeFunc = surroundingAgent.activeFunctionObject as FunctionObject;
+  // 2. Let args be the argumentsList that was passed to this function by [[Call]] or [[Construct]].
+  // 3. Return CreateDynamicFunction(C, NewTarget, async, args).
+  return Q(yield* CreateDynamicFunction(activeFunc, NewTarget, 'async', args, bodyArg));
+}
+
+export function bootstrapAsyncFunction(realmRec: Realm) {
+  const cons = bootstrapConstructor(realmRec, AsyncFunctionConstructor, 'AsyncFunction', 1, realmRec.Intrinsics['%AsyncFunction.prototype%'], []);
+
+  X(cons.DefineOwnProperty(Value('prototype'), Descriptor({
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+
+  cons.Prototype = realmRec.Intrinsics['%Function%'];
+
+  realmRec.Intrinsics['%AsyncFunction%'] = cons;
+}

package/src/intrinsics/AsyncFunctionPrototype.mts

@@ -0,0 +1,8 @@
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { Realm } from '#self';
+
+export function bootstrapAsyncFunctionPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [], realmRec.Intrinsics['%Function.prototype%'], 'AsyncFunction');
+
+  realmRec.Intrinsics['%AsyncFunction.prototype%'] = proto;
+}

package/src/intrinsics/AsyncGeneratorFunction.mts

@@ -0,0 +1,39 @@
+import { Q, X } from '../completion.mts';
+import { CreateDynamicFunction } from '../runtime-semantics/all.mts';
+import { Descriptor, Value } from '../value.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import type {
+  Arguments, ValueEvaluator, FunctionCallContext, FunctionObject, Realm,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorfunction */
+function* AsyncGeneratorFunctionConstructor(args: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  const bodyArg = args[args.length - 1] || Value('');
+  args = args.slice(0, -1) as Arguments;
+  // 1. Let C be the active function object.
+  const activeFunc = surroundingAgent.activeFunctionObject as FunctionObject;
+  // 2. Let args be the argumentsList that was passed to this function by [[Call]] or [[Construct]].
+  // 3. Return ? CreateDynamicFunction(C, NewTarget, asyncGenerator, args).
+  return Q(yield* CreateDynamicFunction(activeFunc, NewTarget, 'asyncGenerator', args, bodyArg));
+}
+
+export function bootstrapAsyncGeneratorFunction(realmRec: Realm) {
+  const cons = bootstrapConstructor(realmRec, AsyncGeneratorFunctionConstructor, 'AsyncGeneratorFunction', 1, realmRec.Intrinsics['%AsyncGeneratorFunction.prototype%'], []);
+
+  X(cons.DefineOwnProperty(Value('prototype'), Descriptor({
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+
+  X((realmRec.Intrinsics['%AsyncGeneratorFunction.prototype%']).DefineOwnProperty(Value('constructor'), Descriptor({
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+
+  cons.Prototype = realmRec.Intrinsics['%Function%'];
+
+  realmRec.Intrinsics['%AsyncGeneratorFunction%'] = cons;
+}

package/src/intrinsics/AsyncGeneratorFunctionPrototype.mts

@@ -0,0 +1,19 @@
+import { X } from '../completion.mts';
+import { Descriptor, Value } from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { Realm } from '#self';
+
+export function bootstrapAsyncGeneratorFunctionPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['prototype', realmRec.Intrinsics['%AsyncGeneratorFunction.prototype.prototype%'], undefined, { Writable: Value.false }],
+  ], realmRec.Intrinsics['%Function.prototype%'], 'AsyncGeneratorFunction');
+
+  X((realmRec.Intrinsics['%AsyncGeneratorFunction.prototype.prototype%']).DefineOwnProperty(Value('constructor'), Descriptor({
+    Value: proto,
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+
+  realmRec.Intrinsics['%AsyncGeneratorFunction.prototype%'] = proto;
+}

package/src/intrinsics/AsyncGeneratorFunctionPrototypePrototype.mts

@@ -0,0 +1,148 @@
+import {
+  X,
+  NormalCompletion,
+  ThrowCompletion,
+  IfAbruptRejectPromise,
+  ReturnCompletion,
+} from '../completion.mts';
+import { Value, type Arguments, type FunctionCallContext } from '../value.mts';
+import { __ts_cast__ } from '../utils/language.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import {
+  Assert,
+  Call,
+  NewPromiseCapability,
+  AsyncGeneratorValidate,
+  AsyncGeneratorEnqueue,
+  AsyncGeneratorResume,
+  AsyncGeneratorAwaitReturn,
+  CreateIteratorResultObject,
+  type AsyncGeneratorObject,
+  Realm,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-asyncgenerator-prototype-next */
+function* AsyncGeneratorPrototype_next([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let generator be the this value.
+  const generator = thisValue;
+  // 2. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 3. Let result be AsyncGeneratorValidate(generator, empty).
+  const result = AsyncGeneratorValidate(generator, undefined);
+  // 4. IfAbruptRejectPromise(result, promiseCapability).
+  IfAbruptRejectPromise(result, promiseCapability);
+  __ts_cast__<AsyncGeneratorObject>(generator);
+  // 5. Let state be generator.[[AsyncGeneratorState]].
+  const state = generator.AsyncGeneratorState;
+  // 6. If state is completed, then
+  if (state === 'completed') {
+    // a. Let iteratorResult be CreateIteratorResultObject(undefined, true).
+    const iteratorResult = CreateIteratorResultObject(Value.undefined, Value.true);
+    // b. Perform ! Call(promiseCapability.[[Resolve]], undefined, « iteratorResult »).
+    X(Call(promiseCapability.Resolve, Value.undefined, [iteratorResult]));
+    // c. Return promiseCapability.[[Promise]].
+    return promiseCapability.Promise;
+  }
+  // 7. Let completion be NormalCompletion(value).
+  const completion = NormalCompletion(value);
+  // 8. Perform AsyncGeneratorEnqueue(generator, completion, promiseCapability).
+  AsyncGeneratorEnqueue(generator, completion, promiseCapability);
+  // 9. If state is either suspendedStart or suspendedYield, then
+  if (state === 'suspendedStart' || state === 'suspendedYield') {
+    // a. Perform AsyncGeneratorResume(generator, completion).
+    yield* AsyncGeneratorResume(generator, completion);
+  } else { // 10. Else,
+    // a. Assert: state is either executing or draining-queue.
+    Assert(state === 'executing' || state === 'draining-queue');
+  }
+  // 11. Return promiseCapability.[[Promise]].
+  return promiseCapability.Promise;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgenerator-prototype-return */
+function* AsyncGeneratorPrototype_return([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let generator be the this value.
+  const generator = thisValue;
+  // 2. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 3. Let result be AsyncGeneratorValidate(generator, empty).
+  const result = AsyncGeneratorValidate(generator, undefined);
+  // 4. IfAbruptRejectPromise(result, promiseCapability).
+  IfAbruptRejectPromise(result, promiseCapability);
+  __ts_cast__<AsyncGeneratorObject>(generator);
+  // 5. Let completion be Completion { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
+  const completion = ReturnCompletion(value);
+  // 6. Perform AsyncGeneratorEnqueue(generator, completion, promiseCapability).
+  AsyncGeneratorEnqueue(generator, completion, promiseCapability);
+  // 7. Let state be generator.[[AsyncGeneratorState]].
+  const state = generator.AsyncGeneratorState;
+  // 8. If state is either suspendedStart or completed, then
+  if (state === 'suspendedStart' || state === 'completed') {
+    // a. Set generator.[[AsyncGeneratorState]] to draining-queue.
+    generator.AsyncGeneratorState = 'draining-queue';
+    // b. Perform AsyncGeneratorAwaitReturn(generator).
+    yield* AsyncGeneratorAwaitReturn(generator);
+  } else if (state === 'suspendedYield') { // 9. Else if state is suspendedYield, then
+    // a. Perform AsyncGeneratorResume(generator, completion).
+    yield* AsyncGeneratorResume(generator, completion);
+  } else { // 10. Else,
+    // a. Assert: state is either executing or draining-queue.
+    Assert(state === 'executing' || state === 'draining-queue');
+  }
+  // 11. Return promiseCapability.[[Promise]].
+  return promiseCapability.Promise;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgenerator-prototype-throw */
+function* AsyncGeneratorPrototype_throw([exception = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let generator be the this value.
+  const generator = thisValue;
+  // 2. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 3. Let result be AsyncGeneratorValidate(generator, empty).
+  const result = AsyncGeneratorValidate(generator, undefined);
+  // 4. IfAbruptRejectPromise(result, promiseCapability).
+  IfAbruptRejectPromise(result, promiseCapability);
+  __ts_cast__<AsyncGeneratorObject>(generator);
+  // 5. Let state be generator.[[AsyncGeneratorState]].
+  let state = generator.AsyncGeneratorState;
+  // 6. If state is suspendedStart, then
+  if (state === 'suspendedStart') {
+    // a. Set generator.[[AsyncGeneratorState]] to completed.
+    generator.AsyncGeneratorState = 'completed';
+    // b. Set state to completed.
+    state = 'completed';
+  }
+  // 7. If state is completed, then
+  if (state === 'completed') {
+    // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « exception »).
+    X(Call(promiseCapability.Reject, Value.undefined, [exception]));
+    // b. Return promiseCapability.[[Promise]].
+    return promiseCapability.Promise;
+  }
+  // 8. Let completion be ThrowCompletion(exception).
+  const completion = ThrowCompletion(exception);
+  // 9. Perform AsyncGeneratorEnqueue(generator, completion, promiseCapability).
+  AsyncGeneratorEnqueue(generator, completion, promiseCapability);
+  // 10. If state is suspendedYield, then
+  if (state === 'suspendedYield') {
+    // a. Perform AsyncGeneratorResume(generator, completion).
+    yield* AsyncGeneratorResume(generator, completion);
+  } else { // 11. Else,
+    // a. Assert: state is either executing or draining-queue.
+    Assert(state === 'executing' || state === 'draining-queue');
+  }
+  // 12. Return promiseCapability.[[Promise]].
+  return promiseCapability.Promise;
+}
+
+export function bootstrapAsyncGeneratorFunctionPrototypePrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', AsyncGeneratorPrototype_next, 1],
+    ['return', AsyncGeneratorPrototype_return, 1],
+    ['throw', AsyncGeneratorPrototype_throw, 1],
+  ], realmRec.Intrinsics['%AsyncIteratorPrototype%'], 'AsyncGenerator');
+
+  realmRec.Intrinsics['%AsyncGeneratorFunction.prototype.prototype%'] = proto;
+}

package/src/intrinsics/AsyncIteratorPrototype.mts

@@ -0,0 +1,56 @@
+import { UndefinedValue, Value, wellKnownSymbols } from '../value.mts';
+import { IfAbruptRejectPromise, X } from '../completion.mts';
+import { __ts_cast__ } from '../utils/language.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import {
+  Call,
+  CreateBuiltinFunction,
+  GetMethod,
+  intrinsics,
+  NewPromiseCapability,
+  PerformPromiseThen,
+  PromiseResolve,
+  type Arguments,
+  type FunctionCallContext,
+  type FunctionObject,
+  type PromiseObject,
+  type Realm,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-%asynciteratorprototype%-%symbol.asyncdispose% */
+function* AsyncIteratorPrototype_asyncDispose(_args: Arguments, { thisValue }: FunctionCallContext) {
+  const obj = thisValue;
+  const promiseCapability = X(NewPromiseCapability(intrinsics()['%Promise%']));
+  const returnMethod = yield* GetMethod(obj, Value('return'));
+  IfAbruptRejectPromise(returnMethod, promiseCapability);
+  __ts_cast__<UndefinedValue | FunctionObject>(returnMethod);
+  if (returnMethod instanceof UndefinedValue) {
+    X(Call(promiseCapability.Resolve, Value.undefined, [Value.undefined]));
+  } else {
+    const result = yield* Call(returnMethod, thisValue, []);
+    IfAbruptRejectPromise(result, promiseCapability);
+    __ts_cast__<Value>(result);
+    const resultWrapper = yield* PromiseResolve(intrinsics()['%Promise%'], result);
+    IfAbruptRejectPromise(resultWrapper, promiseCapability);
+    __ts_cast__<PromiseObject>(resultWrapper);
+    const unwrap = () => Value.undefined;
+    const onFulfilled = CreateBuiltinFunction(unwrap, 1, Value(''), []);
+    PerformPromiseThen(resultWrapper, onFulfilled, Value.undefined, promiseCapability);
+  }
+  return promiseCapability.Promise;
+}
+
+/** https://tc39.es/ecma262/#sec-asynciteratorprototype-asynciterator */
+function AsyncIteratorPrototype_asyncIterator(_args: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Return the this value.
+  return thisValue;
+}
+
+export function bootstrapAsyncIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    [wellKnownSymbols.asyncDispose, AsyncIteratorPrototype_asyncDispose, 0],
+    [wellKnownSymbols.asyncIterator, AsyncIteratorPrototype_asyncIterator, 0],
+  ], realmRec.Intrinsics['%Object.prototype%']);
+
+  realmRec.Intrinsics['%AsyncIteratorPrototype%'] = proto;
+}

package/src/intrinsics/BigInt.mts

@@ -0,0 +1,69 @@
+import {
+  BigIntValue, NumberValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { NumberToBigInt } from '../runtime-semantics/all.mts';
+import { Q, type ValueEvaluator } from '../completion.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import {
+  ToBigInt,
+  ToIndex,
+  ToPrimitive,
+  Throw,
+  Z, R,
+  type OrdinaryObject,
+  Realm,
+} from '#self';
+
+export interface BigIntObject extends OrdinaryObject {
+  readonly BigIntData: BigIntValue;
+}
+export function isBigIntObject(o: Value): o is BigIntObject {
+  return 'BigIntData' in o;
+}
+/** https://tc39.es/ecma262/#sec-bigint-constructor */
+function* BigIntConstructor([value = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  // 1. If NewTarget is not undefined, throw a TypeError exception.
+  if (NewTarget !== Value.undefined) {
+    return Throw.TypeError('BigInt is not a constructor');
+  }
+  // 2. Let prim be ? ToPrimitive(value, number).
+  const prim = Q(yield* ToPrimitive(value, 'number'));
+  // 3. If Type(prim) is Number, return ? NumberToBigInt(prim).
+  // 4. Otherwise, return ? ToBigInt(prim).
+  if (prim instanceof NumberValue) {
+    return Q(NumberToBigInt(prim));
+  } else {
+    return Q(yield* ToBigInt(prim));
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-bigint.asintn */
+function* BigInt_asIntN([_bits = Value.undefined, _bigint = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Set bits to ? ToIndex(bits).
+  const bits = Q(yield* ToIndex(_bits));
+  // 2. Set bigint to ? ToBigInt(bigint).
+  const bigint = Q(yield* ToBigInt(_bigint));
+  // 3. Let mod be the BigInt value that represents bigint modulo 2bits.
+  // 4. If mod ≥ 2^bits - 1, return mod - 2^bits; otherwise, return mod.
+  return Z(BigInt.asIntN(bits, R(bigint)));
+}
+
+/** https://tc39.es/ecma262/#sec-bigint.asuintn */
+function* BigInt_asUintN([_bits = Value.undefined, _bigint = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Set bits to ? ToIndex(bits).
+  const bits = Q(yield* ToIndex(_bits));
+  // 2. Set bigint to ? ToBigInt(bigint).
+  const bigint = Q(yield* ToBigInt(_bigint));
+  // 3. Let mod be ℝ(bigint) modulo 2 ** bits.
+  // 4. If mod ≥ 2 ** (bits - 1), return Z(mod - 2 ** bits); otherwise, return Z(mod).
+  return Z(BigInt.asUintN(bits, R(bigint)));
+}
+
+export function bootstrapBigInt(realmRec: Realm) {
+  const bigintConstructor = bootstrapConstructor(realmRec, BigIntConstructor, 'BigInt', 1, realmRec.Intrinsics['%BigInt.prototype%'], [
+    ['asIntN', BigInt_asIntN, 2],
+    ['asUintN', BigInt_asUintN, 2],
+  ]);
+
+  realmRec.Intrinsics['%BigInt%'] = bigintConstructor;
+}