@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/BigIntPrototype.mts

@@ -0,0 +1,64 @@
+import {
+  ObjectValue, BigIntValue, Value,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  Q, type ValueCompletion, type ValueEvaluator,
+} from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import {
+  Assert, SnapToInteger,
+  Throw,
+} from '#self';
+import type { Integer, Realm } from '#self';
+
+/** https://tc39.es/ecma262/#sec-thisbigintvalue */
+export 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 Throw.TypeError('$1 is not a $2 object', value, 'BigInt');
+}
+
+/** https://tc39.es/ecma262/#sec-bigint.prototype.tolocalestring */
+function BigIntProto_toLocaleString(args: Arguments, context: FunctionCallContext): ValueEvaluator {
+  return BigIntProto_toString(args, context);
+}
+
+/** https://tc39.es/ecma262/#sec-bigint.prototype.tostring */
+function* BigIntProto_toString([radix = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const x = Q(ThisBigIntValue(thisValue));
+  let radixMV: Integer;
+  if (radix === Value.undefined) {
+    radixMV = 10n;
+  } else {
+    radixMV = Q(yield* SnapToInteger(radix, 'truncate', 2n, 36n));
+  }
+  return BigIntValue.toString(x, radixMV);
+}
+
+/** https://tc39.es/ecma262/#sec-bigint.prototype.tostring */
+function BigIntProto_valueOf(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // Return ? thisBigIntValue(this value).
+  return Q(ThisBigIntValue(thisValue));
+}
+
+export function bootstrapBigIntPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['toLocaleString', BigIntProto_toLocaleString, 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 {
+  BooleanValue, UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import {
+  OrdinaryCreateFromConstructor,
+  ToBoolean,
+  type OrdinaryObject,
+  Realm,
+} from '#self';
+
+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): ValueEvaluator {
+  // 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(yield* 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;
+}

package/src/intrinsics/BooleanPrototype.mts

@@ -0,0 +1,56 @@
+import {
+  ObjectValue,
+  BooleanValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { Q, type ValueCompletion } from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { BooleanObject } from './Boolean.mts';
+import { Assert, Throw } from '#self';
+import type { Realm } from '#self';
+
+
+export function ThisBooleanValue(value: Value) {
+  if (value instanceof BooleanValue) {
+    return value;
+  }
+
+  if (value instanceof ObjectValue && 'BooleanData' in value) {
+    const b = value.BooleanData;
+    Assert(b instanceof BooleanValue);
+    return b;
+  }
+
+  return Throw.TypeError('$1 is not a $2 object', value, 'Boolean');
+}
+
+/** https://tc39.es/ecma262/#sec-boolean.prototype.tostring */
+function BooleanProto_toString(_argList: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let b be ? thisBooleanValue(this value).
+  const b = Q(ThisBooleanValue(thisValue));
+  // 2. If b is true, return "true"; else return "false".
+  if (b === Value.true) {
+    return Value('true');
+  }
+  return Value('false');
+}
+
+/** https://tc39.es/ecma262/#sec-boolean.prototype.valueof */
+function BooleanProto_valueOf(_argList: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Return ? thisBooleanValue(this value).
+  return Q(ThisBooleanValue(thisValue));
+}
+
+export function bootstrapBooleanPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['toString', BooleanProto_toString, 0],
+    ['valueOf', BooleanProto_valueOf, 0],
+  ], realmRec.Intrinsics['%Object.prototype%']);
+
+  (proto as Mutable<BooleanObject>).BooleanData = Value.false;
+
+  realmRec.Intrinsics['%Boolean.prototype%'] = proto;
+}

package/src/intrinsics/DataView.mts

@@ -0,0 +1,81 @@
+import {
+  UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { Q } from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../utils/language.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import {
+  IsDetachedBuffer,
+  ArrayBufferByteLength,
+  IsFixedLengthArrayBuffer,
+  OrdinaryCreateFromConstructor,
+  ToIndex,
+  RequireInternalSlot,
+  type OrdinaryObject,
+  type FunctionObject,
+  type ArrayBufferObject,
+  Realm,
+  Throw,
+  Assert,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-dataview-objects */
+export interface DataViewObject extends OrdinaryObject {
+  readonly DataView: string;
+  readonly ViewedArrayBuffer: Value;
+  readonly ByteLength: number | 'auto';
+  readonly ByteOffset: number;
+}
+export function isDataViewObject(V: Value): V is DataViewObject {
+  return 'DataView' in V;
+}
+/** https://tc39.es/ecma262/#sec-dataview-constructor */
+function* DataViewConstructor(this: FunctionObject, [buffer = Value.undefined, byteOffset = Value.undefined, byteLength = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext) {
+  if (NewTarget instanceof UndefinedValue) {
+    return Throw.TypeError('DataView cannot be invoked without new');
+  }
+  Q(RequireInternalSlot(buffer, 'ArrayBufferData'));
+  const offset = Q(yield* ToIndex(byteOffset));
+  __ts_cast__<ArrayBufferObject>(buffer);
+  if (IsDetachedBuffer(buffer)) {
+    return Throw.TypeError('Attempt to access detached ArrayBuffer');
+  }
+  let bufferByteLength = ArrayBufferByteLength(buffer, 'seq-cst');
+  if (offset > bufferByteLength) {
+    return Throw.RangeError('Offset is outside the bounds of the DataView');
+  }
+  const bufferIsFixedLength = IsFixedLengthArrayBuffer(buffer);
+  let viewByteLength: DataViewObject['ByteLength'];
+  if (byteLength === Value.undefined) {
+    viewByteLength = bufferIsFixedLength ? bufferByteLength - offset : 'auto';
+  } else {
+    viewByteLength = Q(yield* ToIndex(byteLength));
+    if (offset + viewByteLength > bufferByteLength) {
+      return Throw.RangeError('Offset is outside the bounds of the DataView');
+    }
+  }
+  const O = Q(yield* OrdinaryCreateFromConstructor(NewTarget, '%DataView.prototype%', ['DataView', 'ViewedArrayBuffer', 'ByteLength', 'ByteOffset'])) as Mutable<DataViewObject>;
+  if (IsDetachedBuffer(buffer)) {
+    return Throw.TypeError('Attempt to access detached ArrayBuffer');
+  }
+  bufferByteLength = ArrayBufferByteLength(buffer, 'seq-cst');
+  if (offset > bufferByteLength) {
+    return Throw.RangeError('Offset is outside the bounds of the DataView');
+  }
+  if (byteLength !== Value.undefined) {
+    Assert(typeof viewByteLength === 'number');
+    if (offset + viewByteLength > bufferByteLength) {
+      return Throw.RangeError('Offset is outside the bounds of the DataView');
+    }
+  }
+  O.ViewedArrayBuffer = buffer;
+  O.ByteLength = viewByteLength;
+  O.ByteOffset = offset;
+  return O;
+}
+
+export function bootstrapDataView(realmRec: Realm) {
+  const dvConstructor = bootstrapConstructor(realmRec, DataViewConstructor, 'DataView', 1, realmRec.Intrinsics['%DataView.prototype%'], []);
+
+  realmRec.Intrinsics['%DataView%'] = dvConstructor;
+}

package/src/intrinsics/DataViewPrototype.mts

@@ -0,0 +1,284 @@
+import { Q, type ValueCompletion, type ValueEvaluator } from '../completion.mts';
+import { Value, type Arguments, type FunctionCallContext } from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { DataViewObject } from './DataView.mts';
+import {
+  Assert,
+  GetViewByteLength,
+  GetViewValue,
+  IsViewOutOfBounds,
+  MakeDataViewWithBufferWitnessRecord,
+  SetViewValue,
+  RequireInternalSlot,
+  F,
+  Realm,
+  Throw,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-get-dataview.prototype.buffer */
+function DataViewProto_buffer(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let O be the this value.
+  const O = thisValue as DataViewObject;
+  // 2. Perform ? RequireInternalSlot(O, [[DataView]]).
+  Q(RequireInternalSlot(O, 'DataView'));
+  // 3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
+  Assert('ViewedArrayBuffer' in O);
+  // 4. Let buffer be O.[[ViewedArrayBuffer]].
+  const buffer = O.ViewedArrayBuffer;
+  // 5. Return buffer.
+  return buffer;
+}
+
+/** https://tc39.es/ecma262/#sec-get-dataview.prototype.bytelength */
+function* DataViewProto_byteLength(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let O be the this value.
+  const O = thisValue as DataViewObject;
+  // 2. Perform ? RequireInternalSlot(O, [[DataView]]).
+  Q(RequireInternalSlot(O, 'DataView'));
+  // 3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
+  Assert('ViewedArrayBuffer' in O);
+  const viewRecord = MakeDataViewWithBufferWitnessRecord(O, 'seq-cst');
+  if (IsViewOutOfBounds(viewRecord)) {
+    return Throw.TypeError('Offset is out of bound');
+  }
+  const size = GetViewByteLength(viewRecord);
+  return F(size);
+}
+
+/** https://tc39.es/ecma262/#sec-get-dataview.prototype.byteoffset */
+function* DataViewProto_byteOffset(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let O be the this value.
+  const O = thisValue as DataViewObject;
+  // 2. Perform ? RequireInternalSlot(O, [[DataView]]).
+  Q(RequireInternalSlot(O, 'DataView'));
+  // 3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
+  Assert('ViewedArrayBuffer' in O);
+  const viewRecord = MakeDataViewWithBufferWitnessRecord(O, 'seq-cst');
+  if (IsViewOutOfBounds(viewRecord)) {
+    return Throw.TypeError('Offset is out of bound');
+  }
+  const offset = O.ByteOffset;
+  return F(offset);
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getbigint64 */
+function* DataViewProto_getBigInt64([byteOffset = Value.undefined, littleEndian = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let v be the this value.
+  const v = thisValue;
+  // 2. Return ? GetViewValue(v, byteOffset, littleEndian, BigInt64).
+  return Q(yield* GetViewValue(v, byteOffset, littleEndian, 'BigInt64'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getbiguint64 */
+function* DataViewProto_getBigUint64([byteOffset = Value.undefined, littleEndian = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let v be the this value.
+  const v = thisValue;
+  // 2. Return ? GetViewValue(v, byteOffset, littleEndian, BigUint64).
+  return Q(yield* GetViewValue(v, byteOffset, littleEndian, 'BigUint64'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getfloat32 */
+function* DataViewProto_getFloat16([byteOffset = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* GetViewValue(v, byteOffset, littleEndian, 'Float16'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getfloat32 */
+function* DataViewProto_getFloat32([byteOffset = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* GetViewValue(v, byteOffset, littleEndian, 'Float32'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getfloat64 */
+function* DataViewProto_getFloat64([byteOffset = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* GetViewValue(v, byteOffset, littleEndian, 'Float64'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getint8 */
+function* DataViewProto_getInt8([byteOffset = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  return Q(yield* GetViewValue(v, byteOffset, Value.true, 'Int8'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getint16 */
+function* DataViewProto_getInt16([byteOffset = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* GetViewValue(v, byteOffset, littleEndian, 'Int16'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getint32 */
+function* DataViewProto_getInt32([byteOffset = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* GetViewValue(v, byteOffset, littleEndian, 'Int32'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getuint8 */
+function* DataViewProto_getUint8([byteOffset = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  return Q(yield* GetViewValue(v, byteOffset, Value.true, 'Uint8'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getuint16 */
+function* DataViewProto_getUint16([byteOffset = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* GetViewValue(v, byteOffset, littleEndian, 'Uint16'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.getuint32 */
+function* DataViewProto_getUint32([byteOffset = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* GetViewValue(v, byteOffset, littleEndian, 'Uint32'));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setbigint64 */
+function* DataViewProto_setBigInt64([byteOffset = Value.undefined, value = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let v be the this value.
+  const v = thisValue;
+  // 2. If littleEndian is not present, set littleEndian to undefined.
+  if (littleEndian === undefined) {
+    littleEndian = Value.undefined;
+  }
+  // 3. Return ? SetViewValue(v, byteOffset, littleEndian, BigInt64, value).
+  return Q(yield* SetViewValue(v, byteOffset, littleEndian, 'BigInt64', value));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setbiguint64 */
+function* DataViewProto_setBigUint64([byteOffset = Value.undefined, value = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let v be the this value.
+  const v = thisValue;
+  // 2. If littleEndian is not present, set littleEndian to undefined.
+  if (littleEndian === undefined) {
+    littleEndian = Value.undefined;
+  }
+  // 3. Return ? SetViewValue(v, byteOffset, littleEndian, BigUint64, value).
+  return Q(yield* SetViewValue(v, byteOffset, littleEndian, 'BigUint64', value));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setfloat32 */
+function* DataViewProto_setFloat16([byteOffset = Value.undefined, value = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* SetViewValue(v, byteOffset, littleEndian, 'Float16', value));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setfloat32 */
+function* DataViewProto_setFloat32([byteOffset = Value.undefined, value = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* SetViewValue(v, byteOffset, littleEndian, 'Float32', value));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setfloat64 */
+function* DataViewProto_setFloat64([byteOffset = Value.undefined, value = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* SetViewValue(v, byteOffset, littleEndian, 'Float64', value));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setint8 */
+function* DataViewProto_setInt8([byteOffset = Value.undefined, value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  return Q(yield* SetViewValue(v, byteOffset, Value.true, 'Int8', value));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setint16 */
+function* DataViewProto_setInt16([byteOffset = Value.undefined, value = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* SetViewValue(v, byteOffset, littleEndian, 'Int16', value));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setint32 */
+function* DataViewProto_setInt32([byteOffset = Value.undefined, value = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* SetViewValue(v, byteOffset, littleEndian, 'Int32', value));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setuint8 */
+function* DataViewProto_setUint8([byteOffset = Value.undefined, value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  return Q(yield* SetViewValue(v, byteOffset, Value.true, 'Uint8', value));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setuint16 */
+function* DataViewProto_setUint16([byteOffset = Value.undefined, value = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* SetViewValue(v, byteOffset, littleEndian, 'Uint16', value));
+}
+
+/** https://tc39.es/ecma262/#sec-dataview.prototype.setuint32 */
+function* DataViewProto_setUint32([byteOffset = Value.undefined, value = Value.undefined, littleEndian]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const v = thisValue;
+  if (littleEndian === undefined) {
+    littleEndian = Value.false;
+  }
+  return Q(yield* SetViewValue(v, byteOffset, littleEndian, 'Uint32', value));
+}
+
+export function bootstrapDataViewPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['buffer', [DataViewProto_buffer]],
+    ['byteLength', [DataViewProto_byteLength]],
+    ['byteOffset', [DataViewProto_byteOffset]],
+    ['getBigInt64', DataViewProto_getBigInt64, 1],
+    ['getBigUint64', DataViewProto_getBigUint64, 1],
+    ['getFloat16', DataViewProto_getFloat16, 1],
+    ['getFloat32', DataViewProto_getFloat32, 1],
+    ['getFloat64', DataViewProto_getFloat64, 1],
+    ['getInt8', DataViewProto_getInt8, 1],
+    ['getInt16', DataViewProto_getInt16, 1],
+    ['getInt32', DataViewProto_getInt32, 1],
+    ['getUint8', DataViewProto_getUint8, 1],
+    ['getUint16', DataViewProto_getUint16, 1],
+    ['getUint32', DataViewProto_getUint32, 1],
+    ['setBigInt64', DataViewProto_setBigInt64, 2],
+    ['setBigUint64', DataViewProto_setBigUint64, 2],
+    ['setFloat16', DataViewProto_setFloat16, 2],
+    ['setFloat32', DataViewProto_setFloat32, 2],
+    ['setFloat64', DataViewProto_setFloat64, 2],
+    ['setInt8', DataViewProto_setInt8, 2],
+    ['setInt16', DataViewProto_setInt16, 2],
+    ['setInt32', DataViewProto_setInt32, 2],
+    ['setUint8', DataViewProto_setUint8, 2],
+    ['setUint16', DataViewProto_setUint16, 2],
+    ['setUint32', DataViewProto_setUint32, 2],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'DataView');
+
+  realmRec.Intrinsics['%DataView.prototype%'] = proto;
+}