@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/intrinsics/AsyncFromSyncIteratorPrototype.mts

@@ -0,0 +1,163 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  AsyncFromSyncIteratorContinuation,
+  Call,
+  CreateIteratorResultObject,
+  GetMethod,
+  IteratorNext,
+  NewPromiseCapability,
+  Assert,
+  type OrdinaryObject,
+  Realm,
+  type IteratorRecord,
+  IteratorClose,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  ObjectValue, UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import {
+  IfAbruptRejectPromise, NormalCompletion, X,
+} from '../completion.mts';
+import { __ts_cast__ } from '../helpers.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+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 = IteratorNext(syncIteratorRecord, value);
+  } else { // 6. Else,
+    // a. Let result be IteratorNext(syncIteratorRecord).
+    result = 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 = 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.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 = Call(ret, syncIterator, [value]);
+  } else { // 9. Else,
+    // a. Let result be Call(return, syncIterator).
+    result = Call(ret, syncIterator);
+  }
+  // 10. IfAbruptRejectPromise(result, promiseCapability).
+  IfAbruptRejectPromise(result, promiseCapability);
+  // 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, [
+      surroundingAgent.Throw('TypeError', 'NotAnObject', 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]: 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 = 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 = IteratorClose(syncIteratorRecord, closeCompletion);
+    IfAbruptRejectPromise(result, promiseCapability);
+    X(Call(promiseCapability.Reject, Value.undefined, [
+      // TODO: error message should be no throw method
+      surroundingAgent.Throw('TypeError', 'NotAnObject', 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 = Call(thr, syncIterator, [value]);
+  } else { // 9. Else,
+    // a. Let result be Call(throw, syncIterator).
+    result = 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, [
+      surroundingAgent.Throw('TypeError', 'NotAnObject', 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,31 @@
+import { surroundingAgent } from '../engine.mts';
+import { Q } from '../completion.mts';
+import { CreateDynamicFunction } from '../runtime-semantics/all.mts';
+import { Descriptor, Value } from '../value.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import type {
+  Arguments, ExpressionCompletion, FunctionCallContext, FunctionObject, Realm,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-async-function-constructor-arguments */
+function AsyncFunctionConstructor(args: Arguments, { NewTarget }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let C be the active function object.
+  const C = 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(CreateDynamicFunction(C, NewTarget, 'async', args));
+}
+
+export function bootstrapAsyncFunction(realmRec: Realm) {
+  const cons = bootstrapConstructor(realmRec, AsyncFunctionConstructor, 'AsyncFunction', 1, realmRec.Intrinsics['%AsyncFunction.prototype%'], []);
+
+  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,37 @@
+import { surroundingAgent } from '../engine.mts';
+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 type {
+  Arguments, ExpressionCompletion, FunctionCallContext, FunctionObject, Realm,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorfunction */
+function AsyncGeneratorFunctionConstructor(args: Arguments, { NewTarget }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let C be the active function object.
+  const C = 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(CreateDynamicFunction(C, NewTarget, 'asyncGenerator', args));
+}
+
+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 { surroundingAgent } from '../engine.mts';
+import {
+  X,
+  Completion,
+  NormalCompletion,
+  ThrowCompletion,
+  IfAbruptRejectPromise,
+} from '../completion.mts';
+import { Value, type Arguments, type FunctionCallContext } from '../value.mts';
+import {
+  Assert,
+  Call,
+  NewPromiseCapability,
+  AsyncGeneratorValidate,
+  AsyncGeneratorEnqueue,
+  AsyncGeneratorResume,
+  AsyncGeneratorAwaitReturn,
+  CreateIteratorResultObject,
+  type AsyncGeneratorObject,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { __ts_cast__ } from '../helpers.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** 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 = X(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).
+  X(AsyncGeneratorEnqueue(generator, completion, promiseCapability));
+  // 9. If state is either suspendedStart or suspendedYield, then
+  if (state === 'suspendedStart' || state === 'suspendedYield') {
+    // a. Perform ! AsyncGeneratorResume(generator, completion).
+    X(AsyncGeneratorResume(generator, completion));
+  } else { // 10. Else,
+    // a. Assert: state is either executing or awaiting-return.
+    Assert(state === 'executing' || state === 'awaiting-return');
+  }
+  // 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 = new Completion({ Type: 'return', Value: value, Target: undefined });
+  // 6. Perform ! AsyncGeneratorEnqueue(generator, completion, promiseCapability).
+  X(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 awaiting-return.
+    generator.AsyncGeneratorState = 'awaiting-return';
+    // b. Perform ! AsyncGeneratorAwaitReturn(generator).
+    X(AsyncGeneratorAwaitReturn(generator));
+  } else if (state === 'suspendedYield') { // 9. Else if state is suspendedYield, then
+    // a. Perform ! AsyncGeneratorResume(generator, completion).
+    X(AsyncGeneratorResume(generator, completion));
+  } else { // 10. Else,
+    // a. Assert: state is either executing or awaiting-return.
+    Assert(state === 'executing' || state === 'awaiting-return');
+  }
+  // 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).
+  X(AsyncGeneratorEnqueue(generator, completion, promiseCapability));
+  // 10. If state is suspendedYield, then
+  if (state === 'suspendedYield') {
+    // a. Perform ! AsyncGeneratorResume(generator, completion).
+    X(AsyncGeneratorResume(generator, completion));
+  } else { // 11. Else,
+    // a. Assert: state is either executing or awaiting-return.
+    Assert(state === 'executing' || state === 'awaiting-return');
+  }
+  // 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,17 @@
+import { wellKnownSymbols } from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { Arguments, FunctionCallContext, Realm } from '#self';
+
+/** 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.asyncIterator, AsyncIteratorPrototype_asyncIterator, 0],
+  ], realmRec.Intrinsics['%Object.prototype%']);
+
+  realmRec.Intrinsics['%AsyncIteratorPrototype%'] = proto;
+}

package/src/intrinsics/BigInt.mts

@@ -0,0 +1,69 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  BigIntValue, NumberValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import {
+  ToBigInt,
+  ToIndex,
+  ToPrimitive,
+  Z, R,
+  type OrdinaryObject,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { NumberToBigInt } from '../runtime-semantics/all.mts';
+import { Q, type ExpressionCompletion } from '../completion.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+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]: Arguments, { NewTarget }: FunctionCallContext): ExpressionCompletion {
+  // 1. If NewTarget is not undefined, throw a TypeError exception.
+  if (NewTarget !== Value.undefined) {
+    return surroundingAgent.Throw('TypeError', 'NotAConstructor', 'BigInt');
+  }
+  // 2. Let prim be ? ToPrimitive(value, number).
+  const prim = Q(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(ToBigInt(prim));
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-bigint.asintn */
+function BigInt_asIntN([_bits = Value.undefined, _bigint = Value.undefined]: Arguments): ExpressionCompletion {
+  // 1. Set bits to ? ToIndex(bits).
+  const bits = Q(ToIndex(_bits));
+  // 2. Set bigint to ? ToBigInt(bigint).
+  const bigint = Q(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): ExpressionCompletion {
+  // 1. Set bits to ? ToIndex(bits).
+  const bits = Q(ToIndex(_bits));
+  // 2. Set bigint to ? ToBigInt(bigint).
+  const bigint = Q(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;
+}

package/src/intrinsics/BigIntPrototype.mts

@@ -0,0 +1,81 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  ObjectValue, BigIntValue, Value,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  Assert, ToIntegerOrInfinity, ToString, R,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-thisbigintvalue */
+function thisBigIntValue(value: Value) {
+  // 1. If Type(value) is BigInt, return value.
+  if (value instanceof BigIntValue) {
+    return value;
+  }
+  // 2. If Type(value) is Object and value has a [[BigIntData]] internal slot, then
+  if (value instanceof ObjectValue && 'BigIntData' in value) {
+    // a. Assert: Type(value.[[BigIntData]]) is BigInt.
+    Assert(value.BigIntData instanceof BigIntValue);
+    // b. Return value.[[BigIntData]].
+    return value.BigIntData;
+  }
+  // 3. Throw a TypeError exception.
+  return surroundingAgent.Throw('TypeError', 'NotATypeObject', 'BigInt', value);
+}
+
+/** https://tc39.es/ecma262/#sec-bigint.prototype.tolocalestring */
+function BigIntProto_toLocalString(args: Arguments, context: FunctionCallContext): ExpressionCompletion {
+  return BigIntProto_toString(args, context);
+}
+
+/** https://tc39.es/ecma262/#sec-bigint.prototype.tostring */
+function BigIntProto_toString([radix]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let x be ? thisBigIntValue(this value).
+  const x = Q(thisBigIntValue(thisValue));
+  // 2. If radix is not present, let radixNumber be 10.
+  let radixNumber;
+  if (radix === undefined) {
+    radixNumber = 10;
+  } else if (radix === Value.undefined) {
+    // 3. Else if radix is undefined, let radixNumber be 10.
+    radixNumber = 10;
+  } else {
+    // 4. Else, let radixNumber be ? ToIntegerOrInfinity(radix).
+    radixNumber = Q(ToIntegerOrInfinity(radix));
+  }
+  // 5. If radixNumber < 2 or radixNumber > 36, throw a RangeError exception.
+  if (radixNumber < 2 || radixNumber > 36) {
+    return surroundingAgent.Throw('RangeError', 'InvalidRadix');
+  }
+  // 6. If radixNumber = 10, return ! ToString(x).
+  if (radixNumber === 10) {
+    return X(ToString(x));
+  }
+  // 7. Return the String representation of this Number value using the radix specified by
+  //    radixNumber. Letters a-z are used for digits with values 10 through 35. The precise
+  //    algorithm is implementation-dependent, however the algorithm should be a
+  //    generalization of that specified in 6.1.6.2.23.
+  // TODO: Implementation stringification
+  return Value(R(x).toString(radixNumber));
+}
+
+/** https://tc39.es/ecma262/#sec-bigint.prototype.tostring */
+function BigIntProto_valueOf(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // Return ? thisBigIntValue(this value).
+  return Q(thisBigIntValue(thisValue));
+}
+
+export function bootstrapBigIntPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['toLocaleString', BigIntProto_toLocalString, 0],
+    ['toString', BigIntProto_toString, 0],
+    ['valueOf', BigIntProto_valueOf, 0],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'BigInt');
+
+  realmRec.Intrinsics['%BigInt.prototype%'] = proto;
+}

package/src/intrinsics/Boolean.mts

@@ -0,0 +1,47 @@
+import {
+  OrdinaryCreateFromConstructor,
+  Realm,
+  ToBoolean,
+  type OrdinaryObject,
+} from '../abstract-ops/all.mts';
+import {
+  BooleanValue, UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+export interface BooleanObject extends OrdinaryObject {
+  readonly BooleanData: BooleanValue;
+}
+export function isBooleanObject(o: Value): o is BooleanObject {
+  return 'BooleanData' in o;
+}
+/** https://tc39.es/ecma262/#sec-boolean-constructor-boolean-value */
+function BooleanConstructor([value = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let b be ! ToBoolean(value).
+  const b = X(ToBoolean(value));
+  // 2. If NewTarget is undefined, return b.
+  if (NewTarget instanceof UndefinedValue) {
+    return b;
+  }
+  // 3. Let O be ? OrdinaryCreateFromConstructor(NewTarget, "%Boolean.prototype%", « [[BooleanData]] »).
+  const O = Q(OrdinaryCreateFromConstructor(NewTarget, '%Boolean.prototype%', ['BooleanData'])) as Mutable<BooleanObject>;
+  // 4. Set O.[[BooleanData]] to b.
+  O.BooleanData = b;
+  // 5. Return O.
+  return O;
+}
+
+export function bootstrapBoolean(realmRec: Realm) {
+  const cons = bootstrapConstructor(
+    realmRec,
+    BooleanConstructor,
+    'Boolean',
+    1,
+    realmRec.Intrinsics['%Boolean.prototype%'],
+    [],
+  );
+
+  realmRec.Intrinsics['%Boolean%'] = cons;
+}