@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/intrinsics/FunctionPrototype.mts

@@ -0,0 +1,274 @@
+import {
+  surroundingAgent,
+  HostHasSourceTextAvailable,
+} from '../host-defined/engine.mts';
+import {
+  Assert,
+  Call,
+  Construct,
+  CreateListFromArrayLike,
+  Get,
+  HasOwnProperty,
+  IsCallable,
+  IsConstructor,
+  OrdinaryHasInstance,
+  PrepareForTailCall,
+  SameValue,
+  SetFunctionLength,
+  SetFunctionName,
+  ToIntegerOrInfinity,
+  CreateBuiltinFunction,
+  MakeBasicObject, R,
+  Realm,
+  type ExoticObject,
+  type FunctionObject,
+  isBuiltinFunctionObject,
+  type BuiltinFunctionObject,
+  hasSourceTextInternalSlot,
+} from '../abstract-ops/all.mts';
+import {
+  JSStringValue,
+  NumberValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  Q, X, type ValueCompletion, type ValueEvaluator,
+} from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../helpers.mts';
+import { assignProps } from './bootstrap.mts';
+
+export interface BoundFunctionObject extends ExoticObject, BuiltinFunctionObject {
+  readonly BoundTargetFunction: FunctionObject;
+  readonly BoundThis: Value;
+  readonly BoundArguments: Arguments;
+}
+
+export function isBoundFunctionObject(object: object): object is BoundFunctionObject {
+  return 'BoundTargetFunction' in object;
+}
+
+/** https://tc39.es/ecma262/#sec-properties-of-the-function-prototype-object */
+function FunctionProto() {
+  // * accepts any arguments and returns undefined when invoked.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.apply */
+function* FunctionProto_apply([thisArg = Value.undefined, argArray = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let func be the this value.
+  const func = thisValue;
+  // 2. If IsCallable(func) is false, throw a TypeError exception.
+  if (!IsCallable(func)) {
+    return surroundingAgent.Throw('TypeError', 'ThisNotAFunction', func);
+  }
+  // 3. If argArray is undefined or null, then
+  if (argArray === Value.undefined || argArray === Value.null) {
+    // a. Perform PrepareForTailCall().
+    PrepareForTailCall();
+    // b. Return ? Call(func, thisArg).
+    return Q(yield* Call(func, thisArg));
+  }
+  // 4. Let argList be ? CreateListFromArrayLike(argArray).
+  const argList = Q(yield* CreateListFromArrayLike(argArray));
+  // 5. Perform PrepareForTailCall().
+  PrepareForTailCall();
+  // 6. Return ? Call(func, thisArg, argList).
+  return Q(yield* Call(func, thisArg, argList));
+}
+
+function* BoundFunctionExoticObjectCall(this: BoundFunctionObject, _thisArgument: ObjectValue, argumentsList: Arguments): ValueEvaluator {
+  const F = this;
+
+  const target = F.BoundTargetFunction;
+  const boundThis = F.BoundThis;
+  const boundArgs = F.BoundArguments;
+  const args = [...boundArgs, ...argumentsList];
+  return Q(yield* Call(target, boundThis, args));
+}
+
+function* BoundFunctionExoticObjectConstruct(this: BoundFunctionObject, argumentsList: Arguments, newTarget: FunctionObject | UndefinedValue): ValueEvaluator<ObjectValue> {
+  const F = this;
+
+  const target = F.BoundTargetFunction;
+  Assert(IsConstructor(target));
+  const boundArgs = F.BoundArguments;
+  const args = [...boundArgs, ...argumentsList];
+  if (SameValue(F, newTarget) === Value.true) {
+    newTarget = target;
+  }
+  return Q(yield* Construct(target, args, newTarget));
+}
+
+/** https://tc39.es/ecma262/#sec-boundfunctioncreate */
+function* BoundFunctionCreate(targetFunction: ObjectValue, boundThis: Value, boundArgs: Arguments): ValueEvaluator<BoundFunctionObject> {
+  // 1. Assert: Type(targetFunction) is Object.
+  Assert(targetFunction instanceof ObjectValue);
+  // 2. Let proto be ? targetFunction.[[GetPrototypeOf]]().
+  const proto = Q(yield* targetFunction.GetPrototypeOf());
+  // 3. Let internalSlotsList be the internal slots listed in Table 30, plus [[Prototype]] and [[Extensible]].
+  const internalSlotsList = [
+    'BoundTargetFunction',
+    'BoundThis',
+    'BoundArguments',
+    'Prototype',
+    'Extensible',
+  ];
+  // 4. Let obj be ! MakeBasicObject(internalSlotsList).
+  const obj = X(MakeBasicObject(internalSlotsList)) as Mutable<BoundFunctionObject>;
+  // 5. Set obj.[[Prototype]] to proto.
+  obj.Prototype = proto;
+  // 6. Set obj.[[Call]] as described in 9.4.1.1.
+  obj.Call = BoundFunctionExoticObjectCall;
+  // 7. If IsConstructor(targetFunction) is true, then
+  if (IsConstructor(targetFunction)) {
+    // a. Set obj.[[Construct]] as described in 9.4.1.2.
+    obj.Construct = BoundFunctionExoticObjectConstruct;
+  }
+  // 8. Set obj.[[BoundTargetFunction]] to targetFunction.
+  obj.BoundTargetFunction = targetFunction as FunctionObject;
+  // 9. Set obj.[[BoundThis]] to boundThis.
+  obj.BoundThis = boundThis;
+  // 10. Set obj.[[BoundArguments]] to boundArguments.
+  obj.BoundArguments = boundArgs;
+  // 11. Return obj.
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.bind */
+function* FunctionProto_bind([thisArg = Value.undefined, ...args]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let Target be the this value.
+  const Target = thisValue;
+  // 2. If IsCallable(Target) is false, throw a TypeError exception.
+  if (!IsCallable(Target)) {
+    return surroundingAgent.Throw('TypeError', 'ThisNotAFunction', Target);
+  }
+  __ts_cast__<ObjectValue>(Target);
+  // 3. Let F be ? BoundFunctionCreate(Target, thisArg, args).
+  const F = Q(yield* BoundFunctionCreate(Target, thisArg, args));
+  // 4. Let L be 0.
+  let L = 0;
+  // 5. Let targetHasLength be ? HasOwnProperty(Target, "length").
+  const targetHasLength = Q(yield* HasOwnProperty(Target, Value('length')));
+  // 6. If targetHasLength is true, then
+  if (targetHasLength === Value.true) {
+    // a. Let targetLen be ? Get(Target, "length").
+    const targetLen = Q(yield* Get(Target, Value('length')));
+    // b. If Type(targetLen) is Number, then
+    if (targetLen instanceof NumberValue) {
+      // i. If targetLen is +∞𝔽, set L to +∞.
+      if (R(targetLen) === +Infinity) {
+        L = +Infinity;
+      } else if (R(targetLen) === -Infinity) { // ii. Else if targetLen is -∞𝔽, set L to 0.
+        L = 0;
+      } else { // iii. Else,
+        // 1. Set targetLen to ! ToIntegerOrInfinity(targetLen).
+        const targetLenAsInt = Q(yield* ToIntegerOrInfinity(targetLen));
+        // 2. Assert: targetLenAsInt is finite.
+        Assert(Number.isFinite(targetLenAsInt));
+        // 3. Let argCount be the number of elements in args.
+        const argCount = args.length;
+        // 4. Set L to max(targetLenAsInt - argCount, 0).
+        L = Math.max(targetLenAsInt - argCount, 0);
+      }
+    }
+  }
+  // 7. Perform ! SetFunctionLength(F, L).
+  X(SetFunctionLength(F, L));
+  // 8. Let targetName be ? Get(Target, "name").
+  let targetName = Q(yield* Get(Target, Value('name')));
+  // 9. If Type(targetName) is not String, set targetName to the empty String.
+  if (!(targetName instanceof JSStringValue)) {
+    targetName = Value('');
+  }
+  // 10. Perform SetFunctionName(F, targetName, "bound").
+  SetFunctionName(F, targetName, Value('bound'));
+  // 11. Return F.
+  return F;
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.call */
+function* FunctionProto_call([thisArg = Value.undefined, ...args]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let func be the this value.
+  const func = thisValue;
+  // 2. If IsCallable(func) is false, throw a TypeError exception.
+  if (!IsCallable(func)) {
+    return surroundingAgent.Throw('TypeError', 'ThisNotAFunction', func);
+  }
+  // 3. Let argList be a new empty List.
+  const argList = [];
+  // 4. If this method was called with more than one argument, then in left to right order, starting with the second argument, append each argument as the last element of argList.
+  for (const arg of args) {
+    argList.push(arg);
+  }
+  // 5. Perform PrepareForTailCall().
+  PrepareForTailCall();
+  // 6. Return ? Call(func, thisArg, argList).
+  return Q(yield* Call(func, thisArg, argList));
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.tostring */
+export function FunctionProto_toString(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion<JSStringValue> {
+  // 1. Let func be the this value.
+  const func = thisValue;
+  // 2. If Type(func) is Object and func has a [[SourceText]] internal slot and func.[[SourceText]]
+  //    is a sequence of Unicode code points and ! HostHasSourceTextAvailable(func) is true, then
+  if (hasSourceTextInternalSlot(func)
+    && X(HostHasSourceTextAvailable(func)) === Value.true) {
+    // Return ! UTF16Encode(func.[[SourceText]]).
+    return Value(func.SourceText);
+  }
+  // 3. If func is a built-in function object, then return an implementation-defined
+  //    String source code representation of func. The representation must have the
+  //    syntax of a NativeFunction. Additionally, if func has an [[InitialName]] internal
+  //    slot and func.[[InitialName]] is a String, the portion of the returned String
+  //    that would be matched by `NativeFunctionAccessor? PropertyName` must be the
+  //    value of func.[[InitialName]].
+  if (isBuiltinFunctionObject(func)) {
+    if (func.InitialName instanceof JSStringValue) {
+      return Value(`function ${func.InitialName.stringValue()}() { [native code] }`);
+    }
+    return Value('function() { [native code] }');
+  }
+  // 4. If Type(func) is Object and IsCallable(func) is true, then return an implementation
+  //    dependent String source code representation of func. The representation must have
+  //    the syntax of a NativeFunction.
+  if (func instanceof ObjectValue && IsCallable(func)) {
+    return Value('function() { [native code] }');
+  }
+  // 5. Throw a TypeError exception.
+  return surroundingAgent.Throw('TypeError', 'NotAFunction', func);
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype-@@hasinstance */
+function* FunctionProto_hasInstance([V = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let F be this value.
+  const F = thisValue;
+  // 2. Return ? OrdinaryHasInstance(F, V).
+  return Q(yield* OrdinaryHasInstance(F, V));
+}
+
+export function bootstrapFunctionPrototype(realmRec: Realm) {
+  const proto = CreateBuiltinFunction(
+    FunctionProto,
+    0,
+    Value(''),
+    [],
+    realmRec,
+    realmRec.Intrinsics['%Object.prototype%'],
+  );
+  realmRec.Intrinsics['%Function.prototype%'] = proto;
+
+  const readonly = { Writable: Value.false, Configurable: Value.false };
+  assignProps(realmRec, proto, [
+    ['apply', FunctionProto_apply, 2],
+    ['bind', FunctionProto_bind, 1],
+    ['call', FunctionProto_call, 1],
+    ['toString', FunctionProto_toString, 0],
+    [wellKnownSymbols.hasInstance, FunctionProto_hasInstance, 1, readonly],
+  ]);
+}

package/src/intrinsics/GeneratorFunction.mts

@@ -0,0 +1,32 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Descriptor, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { DefinePropertyOrThrow, Realm, type FunctionObject } from '../abstract-ops/all.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { CreateDynamicFunction } from '../runtime-semantics/all.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-generatorfunction */
+function* GeneratorFunctionConstructor(args: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  // 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, generator, args).
+  return Q(yield* CreateDynamicFunction(C, NewTarget, 'generator', args));
+}
+
+export function bootstrapGeneratorFunction(realmRec: Realm) {
+  const generator = realmRec.Intrinsics['%GeneratorFunction.prototype%'];
+
+  const cons = bootstrapConstructor(realmRec, GeneratorFunctionConstructor, 'GeneratorFunction', 1, generator, []);
+  X(DefinePropertyOrThrow(cons, Value('prototype'), Descriptor({
+    Writable: Value.false,
+    Configurable: Value.false,
+  })));
+  X(DefinePropertyOrThrow(generator, Value('constructor'), Descriptor({
+    Writable: Value.false,
+  })));
+
+  realmRec.Intrinsics['%GeneratorFunction%'] = cons;
+}

package/src/intrinsics/GeneratorFunctionPrototype.mts

@@ -0,0 +1,21 @@
+import { Descriptor, Value } from '../value.mts';
+import { DefinePropertyOrThrow, Realm } from '../abstract-ops/all.mts';
+import { X } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+export function bootstrapGeneratorFunctionPrototype(realmRec: Realm) {
+  const generatorPrototype = realmRec.Intrinsics['%GeneratorFunction.prototype.prototype%'];
+
+  const generator = bootstrapPrototype(realmRec, [
+    ['prototype', generatorPrototype, undefined, { Writable: Value.false }],
+  ], realmRec.Intrinsics['%Function.prototype%'], 'GeneratorFunction');
+
+  X(DefinePropertyOrThrow(generatorPrototype, Value('constructor'), Descriptor({
+    Value: generator,
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+
+  realmRec.Intrinsics['%GeneratorFunction.prototype%'] = generator;
+}

package/src/intrinsics/GeneratorFunctionPrototypePrototype.mts

@@ -0,0 +1,59 @@
+import {
+  GeneratorResume,
+  GeneratorResumeAbrupt,
+  Realm,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  Completion,
+  ThrowCompletion,
+  Q,
+  X,
+  type ValueEvaluator,
+} from '../completion.mts';
+import {
+  Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-generator.prototype.next */
+function* GeneratorProto_next([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let g be the this value.
+  const g = thisValue;
+  // 2. Return ? GeneratorResume(g, value, empty).
+  return Q(yield* GeneratorResume(g, value, undefined));
+}
+
+/** https://tc39.es/ecma262/#sec-generator.prototype.return */
+function* GeneratorProto_return([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let g be the this value.
+  const g = thisValue;
+  // 2. Let C be Completion { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
+  const C = new Completion({ Type: 'return', Value: value, Target: undefined });
+  // 3. Return ? GeneratorResumeAbrupt(g, C, empty).
+  return Q(yield* GeneratorResumeAbrupt(g, C, undefined));
+}
+
+/** https://tc39.es/ecma262/#sec-generator.prototype.throw */
+function* GeneratorProto_throw([exception = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let g be the this value.
+  const g = thisValue;
+  // 2. Let C be ThrowCompletion(exception).
+  const C = ThrowCompletion(exception);
+  // 3. Return ? GeneratorResumeAbrupt(g, C, empty).
+  return Q(yield* GeneratorResumeAbrupt(g, C, undefined));
+}
+
+export function bootstrapGeneratorFunctionPrototypePrototype(realmRec: Realm) {
+  const generatorPrototype = bootstrapPrototype(realmRec, [
+    ['next', GeneratorProto_next, 1],
+    ['return', GeneratorProto_return, 1],
+    ['throw', GeneratorProto_throw, 1],
+  ], realmRec.Intrinsics['%Iterator.prototype%'], 'Generator');
+
+  realmRec.Intrinsics['%GeneratorFunction.prototype.prototype%'] = generatorPrototype;
+  realmRec.Intrinsics['%GeneratorPrototype%'] = realmRec.Intrinsics['%GeneratorFunction.prototype.prototype%'];
+
+  // Used by `CreateListIteratorRecord`:
+  realmRec.Intrinsics['%GeneratorFunction.prototype.prototype.next%'] = X(generatorPrototype.Get(Value('next'), generatorPrototype)) as FunctionObject;
+}

package/src/intrinsics/Iterator.mts

@@ -0,0 +1,72 @@
+import {
+  GetIteratorFlattenable,
+  OrdinaryCreateFromConstructor,
+  OrdinaryHasInstance,
+  OrdinaryObjectCreate,
+  type BuiltinFunctionObject,
+  type IteratorObject,
+  type Realm,
+} from '../abstract-ops/all.mts';
+import { Q, type ValueEvaluator } from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  type BooleanValue,
+  UndefinedValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+  type ObjectValue,
+} from '../value.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+
+/** https://tc39.es/ecma262/multipage/control-abstraction-objects.html#sec-iterator-constructor */
+function* IteratorConstructor(
+  this: BuiltinFunctionObject,
+  _args: Arguments,
+  { NewTarget }: FunctionCallContext,
+): ValueEvaluator<ObjectValue> {
+  // 1. If NewTarget is either undefined or the active function object, throw a TypeError exception.
+  if (NewTarget instanceof UndefinedValue) {
+    return surroundingAgent.Throw('TypeError', 'ConstructorNonCallable', this);
+  }
+  if (NewTarget === surroundingAgent.activeFunctionObject) {
+    return surroundingAgent.Throw('TypeError', 'CannotConstructAbstractFunction', NewTarget);
+  }
+
+  // 2. Return ? OrdinaryCreateFromConstructor(NewTarget, "%Iterator.prototype%").
+  return Q(yield* OrdinaryCreateFromConstructor(NewTarget, '%Iterator.prototype%'));
+}
+
+/** https://tc39.es/ecma262/#sec-iterator.from */
+function* Iterator_from([O]: Arguments): ValueEvaluator {
+  // 1. Let iteratorRecord be ? GetIteratorFlattenable(O, iterate-string-primitives).
+  const iteratorRecord = Q(yield* GetIteratorFlattenable(O, 'iterate-string-primitives'));
+
+  // 2. Let hasInstance be ? OrdinaryHasInstance(%Iterator%, iteratorRecord.[[Iterator]]).
+  const hasInstance: BooleanValue = Q(yield* OrdinaryHasInstance(surroundingAgent.intrinsic('%Iterator%'), iteratorRecord.Iterator));
+  // 3. If hasInstance is true, then
+  if (hasInstance === Value.true) {
+    // a. Return iteratorRecord.[[Iterator]].
+    return iteratorRecord.Iterator;
+  }
+
+  // 4. Let wrapper be OrdinaryObjectCreate(%WrapForValidIteratorPrototype%, « [[Iterated]] »).
+  const wrapper = OrdinaryObjectCreate(
+    surroundingAgent.intrinsic('%WrapForValidIteratorPrototype%'),
+    ['Iterated'],
+  ) as Mutable<IteratorObject>;
+  // 5. Set wrapper.[[Iterated]] to iteratorRecord.
+  wrapper.Iterated = iteratorRecord;
+  // 6. Return wrapper.
+  return wrapper;
+}
+
+export function bootstrapIterator(realmRec: Realm) {
+  const cons = bootstrapConstructor(realmRec, IteratorConstructor, 'Iterator', 0, realmRec.Intrinsics['%Iterator.prototype%'], [
+    ['from', Iterator_from, 1],
+  ]);
+
+  realmRec.Intrinsics['%Iterator%'] = cons;
+}

package/src/intrinsics/IteratorHelperPrototype.mts

@@ -0,0 +1,61 @@
+import {
+  Assert,
+  CreateIteratorResultObject,
+  GeneratorResume,
+  GeneratorResumeAbrupt,
+  IteratorClose,
+  Realm,
+  RequireInternalSlot,
+  type IteratorRecord,
+} from '../abstract-ops/all.mts';
+import {
+  NormalCompletion, Q, ReturnCompletion, type ValueEvaluator,
+} from '../completion.mts';
+import {
+  Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-%iteratorhelperprototype%.next */
+function* IteratorHelperPrototype_next(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Return ? GeneratorResume(this value, undefined, "Iterator Helper").
+  return Q(yield* GeneratorResume(thisValue, Value.undefined, Value('Iterator Helper')));
+}
+
+/** https://tc39.es/ecma262/#sec-%iteratorhelperprototype%.return */
+function* IteratorHelperPrototype_return(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let O be this value.
+  const O = thisValue;
+  // 2. Perform ? RequireInternalSlot(O, [[UnderlyingIterator]]).
+  Q(RequireInternalSlot(O, 'UnderlyingIterator'));
+  // 3. Assert: O has a [[GeneratorState]] internal slot.
+  Assert('GeneratorState' in O);
+
+  // 4. If O.[[GeneratorState]] is suspended-start, then
+  if (O.GeneratorState === 'suspendedStart') {
+    // a. Set O.[[GeneratorState]] to completed.
+    O.GeneratorState = 'completed';
+
+    // b. NOTE: Once a generator enters the completed state it never leaves it and its associated execution context is never resumed.
+    // Any execution state associated with O can be discarded at this point.
+    // c. Perform ? IteratorClose(O.[[UnderlyingIterator]], NormalCompletion(unused)).
+    Q(yield* IteratorClose((O as unknown as { UnderlyingIterator: IteratorRecord }).UnderlyingIterator, NormalCompletion(undefined)));
+
+    // d. Return CreateIteratorResultObject(undefined, true).
+    return CreateIteratorResultObject(Value.undefined, Value.true);
+  }
+
+  // 5. Let C be ReturnCompletion(undefined).
+  const C = ReturnCompletion(Value.undefined);
+  // 6. Return ? GeneratorResumeAbrupt(O, C, "Iterator Helper").
+  return Q(yield* GeneratorResumeAbrupt(O, C, Value('Iterator Helper')));
+}
+
+export function bootstrapIteratorHelperPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', IteratorHelperPrototype_next, 0],
+    ['return', IteratorHelperPrototype_return, 0],
+  ], realmRec.Intrinsics['%Iterator.prototype%'], 'Iterator Helper');
+
+  realmRec.Intrinsics['%IteratorHelperPrototype%'] = proto;
+}