@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/intrinsics/Error.mts

@@ -0,0 +1,83 @@
+import {
+  DefinePropertyOrThrow,
+  OrdinaryCreateFromConstructor,
+  InstallErrorCause,
+  ToString,
+  Realm,
+  type FunctionObject,
+  IsError,
+} from '../abstract-ops/all.mts';
+import {
+  Descriptor,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+  type JSStringValue,
+  type ObjectValue,
+  type UndefinedValue,
+} from '../value.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { surroundingAgent } from '../host-defined/engine.mts';
+import { captureStack, errorStackToString, type CallSite } from '../helpers.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+export interface ErrorObject extends ObjectValue {
+  ErrorData: JSStringValue;
+  HostDefinedErrorStack?: CallSite[] | UndefinedValue;
+}
+
+export { IsError as isErrorObject } from '../abstract-ops/error-objects.mts';
+
+/** https://tc39.es/ecma262/#sec-error-constructor */
+function* ErrorConstructor([message = Value.undefined, options = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  // 1. If NewTarget is undefined, let newTarget be the active function object; else let newTarget be NewTarget.
+  let newTarget;
+  if (NewTarget === Value.undefined) {
+    newTarget = surroundingAgent.activeFunctionObject;
+  } else {
+    newTarget = NewTarget;
+  }
+  // 2. Let O be ? OrdinaryCreateFromConstructor(newTarget, "%Error.prototype%", « [[ErrorData]] »).
+  const O = Q(yield* OrdinaryCreateFromConstructor(newTarget as FunctionObject, '%Error.prototype%', [
+    'ErrorData',
+    'HostDefinedErrorStack',
+  ])) as ErrorObject;
+  // 3. If message is not undefined, then
+  if (message !== Value.undefined) {
+    // a. Let msg be ? ToString(message).
+    const msg = Q(yield* ToString(message));
+    // b. Let msgDesc be the PropertyDescriptor { [[Value]]: msg, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }.
+    const msgDesc = Descriptor({
+      Value: msg,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.true,
+    });
+    // c. Perform ! DefinePropertyOrThrow(O, "message", msgDesc).
+    X(DefinePropertyOrThrow(O, Value('message'), msgDesc));
+  }
+
+  // 4. Perform ? InstallErrorCause(O, options).
+  Q(yield* InstallErrorCause(O, options));
+
+  // NON-SPEC
+  const S = captureStack();
+  O.HostDefinedErrorStack = S.stack;
+  O.ErrorData = X(errorStackToString(O, S.stack, S.nativeStack));
+
+  // 5. Return O.
+  return O;
+}
+
+/** https://tc39.es/proposal-is-error/#sec-error.iserror */
+function Error_isError([value]: Arguments) {
+  return Value(IsError(value));
+}
+
+export function bootstrapError(realmRec: Realm) {
+  const error = bootstrapConstructor(realmRec, ErrorConstructor, 'Error', 1, realmRec.Intrinsics['%Error.prototype%'], [
+    ['isError', Error_isError, 1],
+  ]);
+
+  realmRec.Intrinsics['%Error%'] = error;
+}

package/src/intrinsics/ErrorPrototype.mts

@@ -0,0 +1,113 @@
+import {
+  surroundingAgent,
+} from '../host-defined/engine.mts';
+import {
+  JSStringValue,
+  ObjectValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+  type UndefinedValue,
+} from '../value.mts';
+import {
+  Assert,
+  Get,
+  Realm,
+  SetterThatIgnoresPrototypeProperties,
+  ToString,
+  type BuiltinFunctionObject,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import { isErrorObject } from './Error.mts';
+
+/** https://tc39.es/ecma262/#sec-error.prototype.tostring */
+function* ErrorProto_toString(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator<JSStringValue> {
+  // 1. Let O be this value.
+  const O = thisValue;
+  // 2. If Type(O) is not Object, throw a TypeError exception.
+  if (!(O instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', O);
+  }
+  // 3. Let name be ? Get(O, "name").
+  let name = Q(yield* Get(O, Value('name')));
+  // 4. If name is undefined, set name to "Error"; otherwise set name to ? ToString(name).
+  if (name === Value.undefined) {
+    name = Value('Error');
+  } else {
+    name = Q(yield* ToString(name));
+  }
+  // 5. Let msg be ? Get(O, "message").
+  let msg = Q(yield* Get(O, Value('message')));
+  // 6. If msg is undefined, set msg to the empty String; otherwise set msg to ? ToString(msg).
+  if (msg === Value.undefined) {
+    msg = Value('');
+  } else {
+    msg = Q(yield* ToString(msg));
+  }
+  // 7. If name is the empty String, return msg.
+  if (name.stringValue() === '') {
+    return msg;
+  }
+  // 8. If msg is the empty String, return name.
+  if (msg.stringValue() === '') {
+    return name;
+  }
+  // 9. Return the string-concatenation of name, the code unit 0x003A (COLON), the code unit 0x0020 (SPACE), and msg.
+  return Value(`${name.stringValue()}: ${msg.stringValue()}`);
+}
+
+/** https://tc39.es/proposal-error-stack-accessor/#sec-get-error.prototype.stack */
+function* ErrorProto_getStack(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator<JSStringValue | UndefinedValue> {
+  // 1. Let E be the this value.
+  const E = thisValue;
+  // 2. If E is not an Object, throw a TypeError exception.
+  if (!(E instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', E);
+  }
+  // 3. If E does not have an [[ErrorData]] internal slot, return undefined.
+  if (!isErrorObject(E)) {
+    return Value.undefined;
+  }
+  // 4. Return an implementation-defined string that represents the stack trace of E.
+  Assert(E.ErrorData instanceof JSStringValue);
+  return E.ErrorData;
+}
+
+/** https://tc39.es/proposal-error-stack-accessor/#sec-set-error.prototype.stack */
+function* ErrorProto_setStack(args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator<UndefinedValue> {
+  const [v = Value.undefined] = args;
+
+  // 1. Let E be the this value.
+  const E = thisValue;
+  // 2. If E is not an Object, throw a TypeError exception.
+  if (!(E instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', E);
+  }
+  // 3. Let numberOfArgs be the number of arguments passed to this function call.
+  const numberOfArgs = args.length;
+  // 4. If numberOfArgs is 0, throw a TypeError exception.
+  if (numberOfArgs === 0) {
+    return surroundingAgent.Throw('TypeError', 'NotEnoughArguments', numberOfArgs, 1);
+  }
+  // 5. If E does not have an [[ErrorData]] internal slot, return undefined.
+  if (!isErrorObject(E)) {
+    return Value.undefined;
+  }
+  // 6. Perform ? SetterThatIgnoresPrototypeProperties(this value, %Error.prototype%, "stack", v).
+  Q(yield* SetterThatIgnoresPrototypeProperties(thisValue, surroundingAgent.intrinsic('%Error.prototype%'), Value('stack'), v));
+  // 7. Return undefined.
+  return Value.undefined;
+}
+
+export function bootstrapErrorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['toString', ErrorProto_toString, 0],
+    ['message', Value('')],
+    ['name', Value('Error')],
+    ['stack', [ErrorProto_getStack, ErrorProto_setStack]],
+  ], realmRec.Intrinsics['%Object.prototype%']);
+
+  realmRec.Intrinsics['%Error.prototype%'] = proto;
+  realmRec.Intrinsics['%Error.prototype.toString%'] = X(Get(proto, Value('toString'))) as BuiltinFunctionObject;
+}

package/src/intrinsics/FinalizationRegistry.mts

@@ -0,0 +1,65 @@
+import { surroundingAgent, HostMakeJobCallback, type JobCallbackRecord } from '../host-defined/engine.mts';
+import {
+  UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import {
+  IsCallable, OrdinaryCreateFromConstructor, Realm,
+  type BuiltinFunctionObject, type FunctionObject, type OrdinaryObject,
+} from '../abstract-ops/all.mts';
+import { Q } from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+export interface FinalizationRegistryCell {
+  WeakRefTarget: Value | undefined;
+  readonly HeldValue: Value;
+  readonly UnregisterToken: Value | undefined;
+}
+export interface FinalizationRegistryObject extends OrdinaryObject {
+  readonly Realm: Realm;
+  readonly CleanupCallback: JobCallbackRecord;
+  Cells: FinalizationRegistryCell[];
+}
+export function isFinalizationRegistryObject(object: object): object is FinalizationRegistryObject {
+  return 'Cells' in object;
+}
+/** https://tc39.es/ecma262/#sec-finalization-registry-cleanup-callback */
+function* FinalizationRegistryConstructor(this: BuiltinFunctionObject, [cleanupCallback = 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. If IsCallable(cleanupCallback) is false, throw a TypeError exception.
+  if (!IsCallable(cleanupCallback)) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', cleanupCallback);
+  }
+  // 3. Let finalizationGroup be ? OrdinaryCreateFromConstructor(NewTarget, "%FinalizationRegistryPrototype%", « [[Realm]], [[CleanupCallback]], [[Cells]] »).
+  const finalizationGroup = Q(yield* OrdinaryCreateFromConstructor(NewTarget, '%FinalizationRegistry.prototype%', [
+    'Realm',
+    'CleanupCallback',
+    'Cells',
+  ])) as Mutable<FinalizationRegistryObject>;
+  // 4. Let fn be the active function object.
+  const fn = surroundingAgent.activeFunctionObject;
+  // 5. Set finalizationGroup.[[Realm]] to fn.[[Realm]].
+  finalizationGroup.Realm = (fn as FunctionObject).Realm;
+  // 6. Set finalizationGroup.[[CleanupCallback]] to HostMakeJobCallback(cleanupCallback).
+  finalizationGroup.CleanupCallback = HostMakeJobCallback(cleanupCallback);
+  // 7. Set finalizationGroup.[[Cells]] to be an empty List.
+  finalizationGroup.Cells = [];
+  // 8. Return finalizationGroup.
+  return finalizationGroup as FinalizationRegistryObject;
+}
+
+export function bootstrapFinalizationRegistry(realmRec: Realm) {
+  const cons = bootstrapConstructor(
+    realmRec,
+    FinalizationRegistryConstructor,
+    'FinalizationRegistry',
+    1,
+    realmRec.Intrinsics['%FinalizationRegistry.prototype%'],
+    [],
+  );
+
+  realmRec.Intrinsics['%FinalizationRegistry%'] = cons;
+}

package/src/intrinsics/FinalizationRegistryPrototype.mts

@@ -0,0 +1,109 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Value, type Arguments, type FunctionCallContext, BooleanValue,
+} from '../value.mts';
+import {
+  CanBeHeldWeakly,
+  CleanupFinalizationRegistry,
+  IsCallable,
+  Realm,
+  RequireInternalSlot,
+  SameValue,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import { Q } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { FinalizationRegistryCell, FinalizationRegistryObject } from './FinalizationRegistry.mts';
+
+/** https://tc39.es/ecma262/#sec-finalization-registry.prototype.cleanupSome */
+function* FinalizationRegistryProto_cleanupSome([callback = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let finalizationRegistry be the this value.
+  const finalizationRegistry = thisValue;
+  // 2. Perform ? RequireInternalSlot(finalizationRegistry, [[Cells]]).
+  Q(RequireInternalSlot(finalizationRegistry, 'Cells'));
+  // 3. If callback is present and IsCallable(callback) is false, throw a TypeError exception.
+  if (callback !== Value.undefined && !IsCallable(callback)) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', callback);
+  }
+  // 4. Perform ? CleanupFinalizationRegistry(finalizationRegistry, callback).
+  Q(yield* CleanupFinalizationRegistry(finalizationRegistry as FinalizationRegistryObject, { Callback: callback as FunctionObject, HostDefined: undefined }));
+  // 5. Return *undefined*.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-finalization-registry.prototype.register */
+function FinalizationRegistryProto_register([target = Value.undefined, heldValue = Value.undefined, unregisterToken = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let finalizationRegistry be the this value.
+  const finalizationRegistry = thisValue as FinalizationRegistryObject;
+  // 2. Perform ? RequireInternalSlot(finalizationRegistry, [[Cells]]).
+  Q(RequireInternalSlot(finalizationRegistry, 'Cells'));
+  // 3. If CanBeHeldWeakly(target) is false, throw a TypeError exception.
+  if (CanBeHeldWeakly(target) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAWeakKey', target);
+  }
+  // 4. If SameValue(target, heldValue), throw a TypeError exception.
+  if (SameValue(target, heldValue) === Value.true) {
+    return surroundingAgent.Throw('TypeError', 'TargetMatchesHeldValue', heldValue);
+  }
+  // 5. If CanBeHeldWeakly(unregisterToken) is false, then
+  if (CanBeHeldWeakly(unregisterToken) === Value.false) {
+    // a. If unregisterToken is not undefined, throw a TypeError exception.
+    if (unregisterToken !== Value.undefined) {
+      return surroundingAgent.Throw('TypeError', 'NotAWeakKey', unregisterToken);
+    }
+    // b. Set unregisterToken to empty.
+    unregisterToken = undefined!;
+  }
+  // 6. Let cell be the Record { [[WeakRefTarget]] : target, [[HeldValue]]: heldValue, [[UnregisterToken]]: unregisterToken }.
+  const cell: FinalizationRegistryCell = {
+    WeakRefTarget: target,
+    HeldValue: heldValue,
+    UnregisterToken: unregisterToken,
+  };
+  // 7. Append cell to finalizationRegistry.[[Cells]].
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(finalizationRegistry));
+  finalizationRegistry.Cells.push(cell);
+  // 8. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-finalization-registry.prototype.unregister */
+function FinalizationRegistryProto_unregister([unregisterToken = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let finalizationRegistry be the this value.
+  const finalizationRegistry = thisValue as FinalizationRegistryObject;
+  // 2. Perform ? RequireInternalSlot(finalizationRegistry, [[Cells]]).
+  Q(RequireInternalSlot(finalizationRegistry, 'Cells'));
+  // 3. If CanBeHeldWeakly(unregisterToken) is false, throw a TypeError exception.
+  if (CanBeHeldWeakly(unregisterToken) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAWeakKey', unregisterToken);
+  }
+  // 4. Let removed be false.
+  let removed: BooleanValue = Value.false;
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(finalizationRegistry));
+  // 5. For each Record { [[WeakRefTarget]], [[HeldValue]], [[UnregisterToken]] } cell that is an element of finalizationRegistry.[[Cells]], do
+  finalizationRegistry.Cells = finalizationRegistry.Cells.filter((cell) => {
+    let r = true;
+    // a. If cell.[[UnregisterToken]] is not empty and SameValue(cell.[[UnregisterToken]], unregisterToken) is true, then
+    if (cell.UnregisterToken !== undefined && SameValue(cell.UnregisterToken, unregisterToken) === Value.true) {
+      // i. Remove cell from finalizationRegistry.Cells.
+      r = false;
+      // ii. Set removed to true.
+      removed = Value.true;
+    }
+    return r;
+  });
+  // 6. Return removed.
+  return removed;
+}
+
+export function bootstrapFinalizationRegistryPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    surroundingAgent.feature('cleanup-some')
+      ? ['cleanupSome', FinalizationRegistryProto_cleanupSome, 0]
+      : undefined,
+    ['register', FinalizationRegistryProto_register, 2],
+    ['unregister', FinalizationRegistryProto_unregister, 1],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'FinalizationRegistry');
+
+  realmRec.Intrinsics['%FinalizationRegistry.prototype%'] = proto;
+}

package/src/intrinsics/ForInIteratorPrototype.mts

@@ -0,0 +1,120 @@
+import {
+  Value, JSStringValue, ObjectValue, type Arguments,
+  type FunctionCallContext,
+  UndefinedValue,
+  NullValue,
+} from '../value.mts';
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Assert,
+  SameValue,
+  OrdinaryObjectCreate,
+  CreateIteratorResultObject,
+  Realm,
+  type OrdinaryObject,
+} from '../abstract-ops/all.mts';
+import { Q, type ValueEvaluator } from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../helpers.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+export interface ForInIteratorInstance extends OrdinaryObject {
+  Object: ObjectValue | NullValue;
+  ObjectWasVisited: Value;
+  readonly VisitedKeys: JSStringValue[];
+  readonly RemainingKeys: JSStringValue[];
+}
+/** https://tc39.es/ecma262/#sec-createforiniterator */
+export function CreateForInIterator(object: ObjectValue) {
+  // 1. Assert: Type(object) is Object.
+  Assert(object instanceof ObjectValue);
+  // 2. Let iterator be ObjectCreate(%ForInIteratorPrototype%, « [[Object]], [[ObjectWasVisited]], [[VisitedKeys]], [[RemainingKeys]] »).
+  const iterator = OrdinaryObjectCreate(surroundingAgent.intrinsic('%ForInIteratorPrototype%'), [
+    'Object',
+    'ObjectWasVisited',
+    'VisitedKeys',
+    'RemainingKeys',
+  ]) as Mutable<ForInIteratorInstance>;
+  // 3. Set iterator.[[Object]] to object.
+  iterator.Object = object;
+  // 4. Set iterator.[[ObjectWasVisited]] to false.
+  iterator.ObjectWasVisited = Value.false;
+  // 5. Set iterator.[[VisitedKeys]] to a new empty List.
+  iterator.VisitedKeys = [];
+  // 6. Set iterator.[[RemainingKeys]] to a new empty List.
+  iterator.RemainingKeys = [];
+  // 7. Return iterator.
+  return iterator;
+}
+
+/** https://tc39.es/ecma262/#sec-%foriniteratorprototype%.next */
+function* ForInIteratorPrototype_next(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let O be this value.
+  const O = thisValue;
+  // 2. Assert: Type(O) is Object.
+  Assert(O instanceof ObjectValue);
+  // 3. Assert: O has all the internal slot sof a For-In Iterator Instance.
+  Assert('Object' in O && 'ObjectWasVisited' in O && 'VisitedKeys' in O && 'RemainingKeys' in O);
+  __ts_cast__<ForInIteratorInstance>(O);
+  // 4. Let object be O.[[Object]].
+  let object: ObjectValue | NullValue = O.Object;
+  // 5. Let visited be O.[[VisitedKeys]].
+  const visited = O.VisitedKeys;
+  // 6. Let remaining be O.[[RemainingKeys]].
+  const remaining = O.RemainingKeys;
+  // 7. Repeat,
+  while (true) {
+    __ts_cast__<ObjectValue>(object);
+    // a. If O.[[ObjectWasVisited]] is false, then
+    if (O.ObjectWasVisited === Value.false) {
+      // i. Let keys be ? object.[[OwnPropertyKeys]]().
+      const keys = Q(yield* object.OwnPropertyKeys());
+      // ii. for each key of keys in List order, do
+      for (const key of keys) {
+        // 1. If Type(key) is String, then
+        if (key instanceof JSStringValue) {
+          // a. Append key to remaining.
+          remaining.push(key);
+        }
+      }
+      // iii. Set O.ObjectWasVisited to true.
+      O.ObjectWasVisited = Value.true;
+    }
+    // b. Repeat, while remaining is not empty,
+    while (remaining.length > 0) {
+      // i. Remove the first element from remaining and let r be the value of the element.
+      const r = remaining.shift()!;
+      // ii. If there does not exist an element v of visisted such that SameValue(r, v) is true, then
+      if (!visited.find((v) => SameValue(r, v) === Value.true)) {
+        // 1. Let desc be ? object.[[GetOwnProperty]](r).
+        const desc = Q(yield* object.GetOwnProperty(r));
+        // 2. If desc is not undefined, then,
+        if (!(desc instanceof UndefinedValue)) {
+          // a. Append r to visited.
+          visited.push(r);
+          // b. If desc.[[Enumerable]] is true, return CreateIteratorResultObject(r, false).
+          if (desc.Enumerable === Value.true) {
+            return CreateIteratorResultObject(r, Value.false);
+          }
+        }
+      }
+    }
+    // c. Set object to ? object.[[GetPrototypeOf]]().
+    object = Q(yield* object.GetPrototypeOf());
+    // d. Set O.Object to object.
+    O.Object = object;
+    // e. Set O.ObjectWasVisited to false.
+    O.ObjectWasVisited = Value.false;
+    // f. If object is null, return CreateIteratorResultObject(undefined, true).
+    if (object === Value.null) {
+      return CreateIteratorResultObject(Value.undefined, Value.true);
+    }
+  }
+}
+
+export function bootstrapForInIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', ForInIteratorPrototype_next, 0],
+  ], realmRec.Intrinsics['%Iterator.prototype%']);
+
+  realmRec.Intrinsics['%ForInIteratorPrototype%'] = proto;
+}

package/src/intrinsics/Function.mts

@@ -0,0 +1,21 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import { Q } from '../completion.mts';
+import { CreateDynamicFunction } from '../runtime-semantics/all.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import type {
+  Arguments, ValueEvaluator, FunctionCallContext, FunctionObject, Realm,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-function-p1-p2-pn-body */
+function* FunctionConstructor(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, normal, args).
+  return Q(yield* CreateDynamicFunction(C, NewTarget, 'normal', args));
+}
+
+export function bootstrapFunction(realmRec: Realm) {
+  const cons = bootstrapConstructor(realmRec, FunctionConstructor, 'Function', 1, realmRec.Intrinsics['%Function.prototype%'], []);
+  realmRec.Intrinsics['%Function%'] = cons;
+}