@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/inspect.mts

@@ -0,0 +1,236 @@
+import { surroundingAgent } from './engine.mts';
+import {
+  Type, JSStringValue, ObjectValue, Value, wellKnownSymbols, BooleanValue, NumberValue, BigIntValue, SymbolValue, PrivateName, UndefinedValue,
+} from './value.mts';
+import {
+  Call, IsArray, Get, LengthOfArrayLike,
+  EscapeRegExpPattern, R, Realm, type BuiltinFunctionObject,
+} from './abstract-ops/all.mts';
+import { Completion, X } from './completion.mts';
+import { isRegExpObject } from './intrinsics/RegExp.mts';
+import type { DateObject } from './intrinsics/Date.mts';
+import type { BooleanObject } from './intrinsics/Boolean.mts';
+import type { NumberObject } from './intrinsics/Number.mts';
+import type { BigIntObject } from './intrinsics/BigInt.mts';
+import type { StringObject } from './intrinsics/String.mts';
+import type { SymbolObject } from './intrinsics/Symbol.mts';
+import { isTypedArrayObject } from './intrinsics/TypedArray.mts';
+import type { Descriptor, PromiseObject } from '#self';
+
+const bareKeyRe = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
+
+function getObjectTag(value: ObjectValue, wrap = false): string {
+  let s = '';
+  try {
+    s = X((Get(value, wellKnownSymbols.toStringTag) as JSStringValue)).stringValue();
+  } catch { }
+  try {
+    const c = X(Get(value, Value('constructor')));
+    s = (X(Get(c as ObjectValue, Value('name'))) as JSStringValue).stringValue();
+  } catch { }
+  if (s) {
+    if (wrap) {
+      return `[${s}] `;
+    }
+    return s;
+  }
+  return '';
+}
+
+const compactObject = (realm: Realm, value: ObjectValue) => {
+  try {
+    const toString = X(Get(value, Value('toString'))) as BuiltinFunctionObject;
+    const objectToString = realm.Intrinsics['%Object.prototype.toString%'];
+    if (toString.nativeFunction === objectToString.nativeFunction) {
+      return (X(Call(toString, value)) as JSStringValue).stringValue();
+    } else {
+      const tag = getObjectTag(value, false) || 'Unknown';
+      const ctor = X(Get(value, Value('constructor')));
+      if (ctor instanceof ObjectValue) {
+        const ctorName = (X(Get(ctor, Value('name'))) as JSStringValue).stringValue();
+        if (ctorName !== '') {
+          return `#<${ctorName}>`;
+        }
+        return `[object ${tag}]`;
+      }
+      return `[object ${tag}]`;
+    }
+  } catch (e) {
+    return '[object Unknown]';
+  }
+};
+
+type Inspecable = Parameters<typeof Type>[0];
+
+type Types = ReturnType<typeof Type>;
+
+interface InspectContext {
+  realm: Realm;
+  indent: number;
+  inspected: Inspecable[];
+  compact: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Inspector = (value: any, context: InspectContext, inner: (v: Inspecable) => string) => string;
+
+const INSPECTORS: Partial<Record<Types, Inspector>> = {
+  Completion: (v: Completion<Inspecable>, _ctx, i) => i(v.Value || Value.undefined),
+  Null: () => 'null',
+  Undefined: () => 'undefined',
+  Boolean: (v: BooleanValue) => v.booleanValue().toString(),
+  Number: (v: NumberValue) => {
+    const n = R(v);
+    if (n === 0 && Object.is(n, -0)) {
+      return '-0';
+    }
+    return n.toString();
+  },
+  BigInt: (v: BigIntValue) => `${R(v)}n`,
+  String: (v: JSStringValue) => {
+    const s = JSON.stringify(v.stringValue()).slice(1, -1);
+    return `'${s}'`;
+  },
+  Symbol: (v: SymbolValue) => `Symbol(${v.Description instanceof UndefinedValue ? '' : v.Description.stringValue()})`,
+  PrivateName: (v: PrivateName) => v.Description.stringValue(),
+  Object: (v: ObjectValue, ctx, i) => {
+    if (ctx.inspected.includes(v)) {
+      return '[Circular]';
+    }
+    if ('PromiseState' in v) {
+      ctx.indent += 1;
+      const result = v.PromiseState === 'pending' ? 'undefined' : i((v as PromiseObject).PromiseResult!);
+      ctx.indent -= 1;
+      return `Promise {
+  [[PromiseState]]: ${v.PromiseState}
+  [[PromiseResult]]: ${result}
+}`;
+    }
+
+    if ('Call' in v) {
+      const name = v.properties.get('name');
+      if (name && (name.Value! as JSStringValue).stringValue() !== '') {
+        return `[Function: ${(name.Value as JSStringValue).stringValue()}]`;
+      }
+      return '[Function]';
+    }
+
+    if ('ErrorData' in v) {
+      let e = X(Get(v, Value('stack')));
+      if (!(e as JSStringValue).stringValue) {
+        const toString = X(Get(v, Value('toString')));
+        e = X(Call(toString, v));
+      }
+      return (e as JSStringValue).stringValue();
+    }
+
+    if (isRegExpObject(v)) {
+      const P = EscapeRegExpPattern(v.OriginalSource, v.OriginalFlags).stringValue();
+      const F = v.OriginalFlags.stringValue();
+      return `/${P}/${F}`;
+    }
+
+    if ('DateValue' in v) {
+      const d = new Date(R((v as DateObject).DateValue));
+      if (Number.isNaN(d.getTime())) {
+        return '[Date Invalid]';
+      }
+      return `[Date ${d.toISOString()}]`;
+    }
+
+    if ('BooleanData' in v) {
+      return `[Boolean ${i((v as BooleanObject).BooleanData)}]`;
+    }
+    if ('NumberData' in v) {
+      return `[Number ${i((v as NumberObject).NumberData)}]`;
+    }
+    if ('BigIntData' in v) {
+      return `[BigInt ${i((v as BigIntObject).BigIntData)}]`;
+    }
+    if ('StringData' in v) {
+      return `[String ${i((v as StringObject).StringData)}]`;
+    }
+    if ('SymbolData' in v) {
+      return `[Symbol ${i((v as SymbolObject).SymbolData)}]`;
+    }
+
+    ctx.indent += 1;
+    ctx.inspected.push(v);
+
+    try {
+      const isArray = IsArray(v) === Value.true;
+      const isTypedArray = isTypedArrayObject(v);
+      if (isArray || isTypedArray) {
+        const length = X(LengthOfArrayLike(v));
+        let holes = 0;
+        const flushHoles = () => {
+          if (holes > 0) {
+            out.push(`<${holes} empty items>`);
+            holes = 0;
+          }
+        };
+        const out = [];
+        for (let j = 0; j < length; j += 1) {
+          const elem = X(v.GetOwnProperty(Value(j.toString())));
+          if (elem instanceof UndefinedValue) {
+            holes += 1;
+          } else {
+            flushHoles();
+            if (elem.Value) {
+              out.push(i(elem.Value));
+            } else {
+              out.push('<accessor>');
+            }
+          }
+        }
+        flushHoles();
+        return `${isTypedArray ? `${v.TypedArrayName.stringValue()} ` : ''}[${out.join(', ')}]`;
+      }
+
+      const keys = X(v.OwnPropertyKeys());
+      const cache = [];
+      for (const key of keys) {
+        const C = X(v.GetOwnProperty(key)) as Descriptor;
+        if (C.Enumerable === Value.true) {
+          cache.push([
+            key instanceof JSStringValue && bareKeyRe.test(key.stringValue()) ? key.stringValue() : i(key),
+            C.Value ? i(C.Value) : '<accessor>',
+          ]);
+        }
+      }
+
+      const tag = getObjectTag(v);
+      let out = tag && tag !== 'Object' ? `${tag} {` : '{';
+      if (cache.length > 5) {
+        cache.forEach((c) => {
+          out = `${out}\n${'  '.repeat(ctx.indent)}${c[0]}: ${c[1]},`;
+        });
+        return `${out}\n${'  '.repeat(ctx.indent - 1)}}`;
+      } else {
+        const oc = ctx.compact;
+        ctx.compact = true;
+        cache.forEach((c, index) => {
+          out = `${out}${index === 0 ? '' : ','} ${c[0]}: ${c[1]}`;
+        });
+        ctx.compact = oc;
+        return `${out} }`;
+      }
+    } catch {
+      return compactObject(ctx.realm, v);
+    } finally {
+      ctx.indent -= 1;
+      ctx.inspected.pop();
+    }
+  },
+};
+
+export function inspect(value: Value | Completion<unknown>) {
+  const context: InspectContext = {
+    realm: surroundingAgent.currentRealmRecord,
+    indent: 0,
+    inspected: [],
+    compact: false,
+  };
+  const inner = (v: Inspecable) => INSPECTORS[Type(v)]!(v, context, inner);
+  return inner(value);
+}

package/src/intrinsics/AggregateError.mts

@@ -0,0 +1,64 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Value, Descriptor, type Arguments, type FunctionCallContext,
+  UndefinedValue,
+} from '../value.mts';
+import {
+  ToString,
+  IteratorToList,
+  OrdinaryCreateFromConstructor,
+  DefinePropertyOrThrow,
+  InstallErrorCause,
+  CreateArrayFromList,
+  Realm,
+  type FunctionObject,
+  CreateNonEnumerableDataPropertyOrThrow,
+  GetIterator,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import { captureStack } from '../helpers.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-aggregate-error-constructor */
+function AggregateErrorConstructor([errors = Value.undefined, message = Value.undefined, options = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext): ExpressionCompletion {
+  // 1. If NewTarget is undefined, let newTarget be the active function object, else let newTarget be NewTarget.
+  let newTarget;
+  if (NewTarget instanceof UndefinedValue) {
+    newTarget = surroundingAgent.activeFunctionObject as FunctionObject;
+  } else {
+    newTarget = NewTarget;
+  }
+  // 2. Let O be ? OrdinaryCreateFromConstructor(newTarget, "%AggregateError.prototype%", « [[ErrorData]] »).
+  const O = Q(OrdinaryCreateFromConstructor(newTarget, '%AggregateError.prototype%', [
+    'ErrorData',
+  ]));
+  // 3. If message is not undefined, then
+  if (message !== Value.undefined) {
+    // a. Let msg be ? ToString(message).
+    const msg = Q(ToString(message));
+    // b. Perform ! CreateMethodProperty(O, "message", msg).
+    X(CreateNonEnumerableDataPropertyOrThrow(O, Value('message'), msg));
+  }
+  Q(InstallErrorCause(O, options));
+  // 4. Let errorsList be ? IterableToList(errors).
+  const errorsList = Q(IteratorToList(Q(GetIterator(errors, 'sync'))));
+  // 5. Perform ! DefinePropertyOrThrow(O, "errors", Property Descriptor { [[Configurable]]: true, [[Enumerable]]: false, [[Writable]]: true, [[Value]]: ! CreateArrayFromList(errorsList) }).
+  X(DefinePropertyOrThrow(O, Value('errors'), Descriptor({
+    Configurable: Value.true,
+    Enumerable: Value.false,
+    Writable: Value.true,
+    Value: CreateArrayFromList(errorsList),
+  })));
+
+  // NON-SPEC
+  X(captureStack(O));
+
+  // 7. Return O.
+  return O;
+}
+
+export function bootstrapAggregateError(realmRec: Realm) {
+  const c = bootstrapConstructor(realmRec, AggregateErrorConstructor, 'AggregateError', 2, realmRec.Intrinsics['%AggregateError.prototype%'], []);
+  c.Prototype = realmRec.Intrinsics['%Error%'];
+  realmRec.Intrinsics['%AggregateError%'] = c;
+}

package/src/intrinsics/AggregateErrorPrototype.mts

@@ -0,0 +1,12 @@
+import { Value } from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { Realm } from '#self';
+
+export function bootstrapAggregateErrorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['name', Value('AggregateError')],
+    ['message', Value('')],
+  ], realmRec.Intrinsics['%Error.prototype%'], 'AggregateError');
+
+  realmRec.Intrinsics['%AggregateError.prototype%'] = proto;
+}

package/src/intrinsics/Array.mts

@@ -0,0 +1,216 @@
+import {
+  surroundingAgent,
+} from '../engine.mts';
+import {
+  IfAbruptCloseIterator,
+  Q,
+  ThrowCompletion, X,
+  type ExpressionCompletion,
+} from '../completion.mts';
+import {
+  ArrayCreate,
+  Assert,
+  Call,
+  Construct,
+  CreateDataProperty,
+  CreateDataPropertyOrThrow,
+  Get,
+  GetMethod,
+  GetPrototypeFromConstructor,
+  IsArray,
+  IsCallable,
+  IsConstructor,
+  IteratorClose,
+  Set,
+  LengthOfArrayLike,
+  ToObject,
+  ToString,
+  ToUint32,
+  F, R,
+  Realm,
+  type FunctionObject,
+  IteratorStepValue,
+  GetIteratorFromMethod,
+} from '../abstract-ops/all.mts';
+import {
+  NumberValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { __ts_cast__, OutOfRange } from '../helpers.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-array-constructor */
+function ArrayConstructor(argumentsList: Arguments, { NewTarget }: FunctionCallContext) {
+  const numberOfArgs = argumentsList.length;
+  if (numberOfArgs === 0) {
+    /** https://tc39.es/ecma262/#sec-array-constructor-array */
+    Assert(numberOfArgs === 0);
+    if (NewTarget instanceof UndefinedValue) {
+      NewTarget = surroundingAgent.activeFunctionObject as FunctionObject;
+    }
+    const proto = X(GetPrototypeFromConstructor(NewTarget, '%Array.prototype%'));
+    return ArrayCreate(0, proto);
+  } else if (numberOfArgs === 1) {
+    /** https://tc39.es/ecma262/#sec-array-len */
+    const [len] = argumentsList;
+    Assert(numberOfArgs === 1);
+    if (NewTarget instanceof UndefinedValue) {
+      NewTarget = surroundingAgent.activeFunctionObject as FunctionObject;
+    }
+    const proto = X(GetPrototypeFromConstructor(NewTarget, '%Array.prototype%'));
+    const array = X(ArrayCreate(0, proto));
+    let intLen;
+    if (!(len instanceof NumberValue)) {
+      const defineStatus = X(CreateDataProperty(array, Value('0'), len));
+      Assert(defineStatus === Value.true);
+      intLen = F(1);
+    } else {
+      intLen = X(ToUint32(len));
+      if (R(intLen) !== R(len)) {
+        return surroundingAgent.Throw('RangeError', 'InvalidArrayLength', len);
+      }
+    }
+    Set(array, Value('length'), intLen, Value.true);
+    return array;
+  } else if (numberOfArgs >= 2) {
+    /** https://tc39.es/ecma262/#sec-array-items */
+    const items = argumentsList;
+    Assert(numberOfArgs >= 2);
+    if (NewTarget instanceof UndefinedValue) {
+      NewTarget = surroundingAgent.activeFunctionObject as FunctionObject;
+    }
+    const proto = Q(GetPrototypeFromConstructor(NewTarget, '%Array.prototype%'));
+    const array = X(ArrayCreate(0, proto));
+    let k = 0;
+    while (k < numberOfArgs) {
+      const Pk = X(ToString(F(k)));
+      const itemK = items[k];
+      const defineStatus = X(CreateDataProperty(array, Pk, itemK));
+      Assert(defineStatus === Value.true);
+      k += 1;
+    }
+    Assert(R(X(Get(array, Value('length')) as NumberValue)) === numberOfArgs);
+    return array;
+  }
+
+  throw new OutOfRange('ArrayConstructor', numberOfArgs);
+}
+
+/** https://tc39.es/ecma262/#sec-array.from */
+function Array_from([items = Value.undefined, mapper = Value.undefined, thisArg = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  const C = thisValue;
+  let mapping;
+  let A;
+  if (mapper === Value.undefined) {
+    mapping = false;
+  } else {
+    if (IsCallable(mapper) === Value.false) {
+      return surroundingAgent.Throw('TypeError', 'NotAFunction', mapper);
+    }
+    mapping = true;
+  }
+  const usingIterator = Q(GetMethod(items, wellKnownSymbols.iterator));
+  if (!(usingIterator instanceof UndefinedValue)) {
+    if (IsConstructor(C) === Value.true) {
+      A = Q(Construct(C as FunctionObject));
+    } else {
+      A = X(ArrayCreate(0));
+    }
+    const iteratorRecord = Q(GetIteratorFromMethod(items, usingIterator));
+    let k = 0;
+    while (true) { // eslint-disable-line no-constant-condition
+      if (k >= (2 ** 53) - 1) {
+        const error = ThrowCompletion(surroundingAgent.Throw('TypeError', 'ArrayPastSafeLength').Value);
+        return Q(IteratorClose(iteratorRecord, error));
+      }
+      const Pk = X(ToString(F(k)));
+      const next = Q(IteratorStepValue(iteratorRecord));
+      if (next === 'done') {
+        Q(Set(A, Value('length'), F(k), Value.true));
+        return A;
+      }
+      let mappedValue;
+      if (mapping) {
+        mappedValue = Call(mapper, thisArg, [next, F(k)]);
+        IfAbruptCloseIterator(mappedValue, iteratorRecord);
+        __ts_cast__<Value>(mappedValue);
+      } else {
+        mappedValue = next;
+      }
+      const defineStatus = CreateDataPropertyOrThrow(A, Pk, mappedValue);
+      IfAbruptCloseIterator(defineStatus, iteratorRecord);
+      k += 1;
+    }
+  }
+  const arrayLike = X(ToObject(items));
+  const len = Q(LengthOfArrayLike(arrayLike));
+  if (IsConstructor(C) === Value.true) {
+    A = Q(Construct(C as FunctionObject, [F(len)]));
+  } else {
+    A = Q(ArrayCreate(len));
+  }
+  let k = 0;
+  while (k < len) {
+    const Pk = X(ToString(F(k)));
+    const kValue = Q(Get(arrayLike, Pk));
+    let mappedValue;
+    if (mapping === true) {
+      mappedValue = Q(Call(mapper, thisArg, [kValue, F(k)]));
+    } else {
+      mappedValue = kValue;
+    }
+    Q(CreateDataPropertyOrThrow(A, Pk, mappedValue));
+    k += 1;
+  }
+  Q(Set(A, Value('length'), F(len), Value.true));
+  return A;
+}
+
+/** https://tc39.es/ecma262/#sec-array.isarray */
+function Array_isArray([arg = Value.undefined]: Arguments): ExpressionCompletion {
+  return Q(IsArray(arg));
+}
+
+/** https://tc39.es/ecma262/#sec-array.of */
+function Array_of(items: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  const len = items.length;
+  // Let items be the List of arguments passed to this function.
+  const C = thisValue;
+  let A;
+  if (IsConstructor(C) === Value.true) {
+    A = Q(Construct(C as FunctionObject, [F(len)]));
+  } else {
+    A = Q(ArrayCreate(len));
+  }
+  let k = 0;
+  while (k < len) {
+    const kValue = items[k];
+    const Pk = X(ToString(F(k)));
+    Q(CreateDataPropertyOrThrow(A, Pk, kValue));
+    k += 1;
+  }
+  Q(Set(A, Value('length'), F(len), Value.true));
+  return A;
+}
+
+/** https://tc39.es/ecma262/#sec-get-array-@@species */
+function Array_speciesGetter(_args: Arguments, { thisValue }: FunctionCallContext) {
+  return thisValue;
+}
+
+export function bootstrapArray(realmRec: Realm) {
+  const proto = realmRec.Intrinsics['%Array.prototype%'];
+
+  const cons = bootstrapConstructor(realmRec, ArrayConstructor, 'Array', 1, proto, [
+    ['from', Array_from, 1],
+    ['isArray', Array_isArray, 1],
+    ['of', Array_of, 0],
+    [wellKnownSymbols.species, [Array_speciesGetter]],
+  ]);
+
+  realmRec.Intrinsics['%Array%'] = cons;
+}

package/src/intrinsics/ArrayBuffer.mts

@@ -0,0 +1,48 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  ObjectValue, UndefinedValue, Value, wellKnownSymbols, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { Q } from '../completion.mts';
+import {
+  ToIndex, AllocateArrayBuffer, type FunctionObject, Realm,
+} from '../abstract-ops/all.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-arraybuffer-length */
+function ArrayBufferConstructor(this: FunctionObject, [length = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext) {
+  // 1. If NewTarget is undefined, throw a TypeError exception.
+  if (NewTarget instanceof UndefinedValue) {
+    return surroundingAgent.Throw('TypeError', 'ConstructorNonCallable', this);
+  }
+  // 2. Let byteLength be ? ToIndex(length).
+  const byteLength = Q(ToIndex(length));
+  // 3. Return ? AllocateArrayBuffer(NewTarget, byteLength).
+  return Q(AllocateArrayBuffer(NewTarget, byteLength));
+}
+
+/** https://tc39.es/ecma262/#sec-arraybuffer.isview */
+function ArrayBuffer_isView([arg = Value.undefined]: Arguments) {
+  // 1. If Type(arg) is not Object, return false.
+  if (!(arg instanceof ObjectValue)) {
+    return Value.false;
+  }
+  // 2. If arg has a [[ViewedArrayBuffer]] internal slot, return true.
+  if ('ViewedArrayBuffer' in arg) {
+    return Value.true;
+  }
+  // 3. Return false.
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-get-arraybuffer-@@species */
+function ArrayBuffer_species(_: Arguments, { thisValue }: FunctionCallContext) {
+  return thisValue;
+}
+
+export function bootstrapArrayBuffer(realmRec: Realm) {
+  const c = bootstrapConstructor(realmRec, ArrayBufferConstructor, 'ArrayBuffer', 1, realmRec.Intrinsics['%ArrayBuffer.prototype%'], [
+    ['isView', ArrayBuffer_isView, 1],
+    [wellKnownSymbols.species, [ArrayBuffer_species]],
+  ]);
+  realmRec.Intrinsics['%ArrayBuffer%'] = c;
+}

package/src/intrinsics/ArrayBufferPrototype.mts

@@ -0,0 +1,120 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  DataBlock, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { Q } from '../completion.mts';
+import {
+  RequireInternalSlot, IsDetachedBuffer, IsSharedArrayBuffer,
+  SpeciesConstructor, Construct, ToIntegerOrInfinity, SameValue, CopyDataBlockBytes,
+  F,
+  Realm,
+  type ArrayBufferObject,
+} from '../abstract-ops/all.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-get-arraybuffer.prototype.bytelength */
+function ArrayBufferProto_byteLength(_args: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let O be this value.
+  const O = thisValue as ArrayBufferObject;
+  // 2. Perform ? RequireInternalSlot(O, [[ArrayBufferData]]).
+  Q(RequireInternalSlot(O, 'ArrayBufferData'));
+  // 3. If IsSharedArrayBuffer(O) is true, throw a TypeError exception.
+  if (IsSharedArrayBuffer(O) === Value.true) {
+    return surroundingAgent.Throw('TypeError', 'ArrayBufferShared');
+  }
+  // 4. If IsDetachedBuffer(O) is true, return +0𝔽.
+  if (IsDetachedBuffer(O) === Value.true) {
+    return F(+0);
+  }
+  // 5. Let length be O.[[ArrayBufferByteLength]].
+  const length = O.ArrayBufferByteLength;
+  // 6. Return length.
+  return F(length);
+}
+
+/** https://tc39.es/ecma262/#sec-arraybuffer.prototype.slice */
+function ArrayBufferProto_slice([start = Value.undefined, end = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let O be the this value.
+  const O = thisValue as ArrayBufferObject;
+  // 2. Perform ? RequireInternalSlot(O, [[ArrayBufferData]]).
+  Q(RequireInternalSlot(O, 'ArrayBufferData'));
+  // 3. If IsSharedArrayBuffer(O) is true, throw a TypeError exception.
+  if (IsSharedArrayBuffer(O) === Value.true) {
+    return surroundingAgent.Throw('TypeError', 'ArrayBufferShared');
+  }
+  // 4. If IsDetachedBuffer(O) is true, throw a TypeError exception.
+  if (IsDetachedBuffer(O) === Value.true) {
+    return surroundingAgent.Throw('TypeError', 'ArrayBufferDetached');
+  }
+  // 5. Let len be O.[[ArrayBufferByteLength]].
+  const len = O.ArrayBufferByteLength;
+  // 6. Let relativeStart be ? ToIntegerOrInfinity(start).
+  const relativeStart = Q(ToIntegerOrInfinity(start));
+  let first;
+  // 7. If relativeStart < 0, let first be max((len + relativeStart), 0); else let first be min(relativeStart, len).
+  if (relativeStart < 0) {
+    first = Math.max(len + relativeStart, 0);
+  } else {
+    first = Math.min(relativeStart, len);
+  }
+  let relativeEnd;
+  // 8. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToIntegerOrInfinity(end).
+  if (end === Value.undefined) {
+    relativeEnd = len;
+  } else {
+    relativeEnd = Q(ToIntegerOrInfinity(end));
+  }
+  let final;
+  // 9. If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
+  if (relativeEnd < 0) {
+    final = Math.max(len + relativeEnd, 0);
+  } else {
+    final = Math.min(relativeEnd, len);
+  }
+  // 10. Let newLen be max(final - first, 0).
+  const newLen = Math.max(final - first, 0);
+  // 11. Let ctor be ? SpeciesConstructor(O, %ArrayBuffer%).
+  const ctor = Q(SpeciesConstructor(O, surroundingAgent.intrinsic('%ArrayBuffer%')));
+  // 12. Let new be ? Construct(ctor, « newLen »).
+  const newO = Q(Construct(ctor, [F(newLen)])) as ArrayBufferObject;
+  // 13. Perform ? RequireInternalSlot(new, [[ArrayBufferData]]).
+  Q(RequireInternalSlot(newO, 'ArrayBufferData'));
+  // 14. If IsSharedArrayBuffer(new) is true, throw a TypeError exception.
+  if (IsSharedArrayBuffer(newO) === Value.true) {
+    return surroundingAgent.Throw('TypeError', 'ArrayBufferShared');
+  }
+  // 15. If IsDetachedBuffer(new) is true, throw a TypeError exception.
+  if (IsDetachedBuffer(newO) === Value.true) {
+    return surroundingAgent.Throw('TypeError', 'ArrayBufferDetached');
+  }
+  // 16. If SameValue(new, O) is true, throw a TypeError exception.
+  if (SameValue(newO, O) === Value.true) {
+    return surroundingAgent.Throw('TypeError', 'SubclassSameValue', newO);
+  }
+  // 17. If new.[[ArrayBufferByteLength]] < newLen, throw a TypeError exception.
+  if (newO.ArrayBufferByteLength < newLen) {
+    return surroundingAgent.Throw('TypeError', 'SubclassLengthTooSmall', newO);
+  }
+  // 18. NOTE: Side-effects of the above steps may have detached O.
+  // 19. If IsDetachedBuffer(O) is true, throw a TypeError exception.
+  if (IsDetachedBuffer(O) === Value.true) {
+    return surroundingAgent.Throw('TypeError', 'ArrayBufferDetached');
+  }
+  // 20. Let fromBuf be O.[[ArrayBufferData]].
+  const fromBuf = O.ArrayBufferData as DataBlock;
+  // 21. Let toBuf be new.[[ArrayBufferData]].
+  const toBuf = newO.ArrayBufferData as DataBlock;
+  // 22. Perform CopyDataBlockBytes(toBuf, 0, fromBuf, first, newLen).
+  CopyDataBlockBytes(toBuf, 0, fromBuf, first, newLen);
+  // 23. Return new.
+  return newO;
+}
+
+export function bootstrapArrayBufferPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['byteLength', [ArrayBufferProto_byteLength]],
+    ['slice', ArrayBufferProto_slice, 2],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'ArrayBuffer');
+
+  realmRec.Intrinsics['%ArrayBuffer.prototype%'] = proto;
+}