@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/intrinsics/PromisePrototype.mts

@@ -0,0 +1,120 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Assert,
+  Call,
+  CreateBuiltinFunction,
+  Get,
+  Invoke,
+  IsCallable,
+  IsConstructor,
+  IsPromise,
+  NewPromiseCapability,
+  PerformPromiseThen,
+  PromiseResolve,
+  Realm,
+  SpeciesConstructor,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  ObjectValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import {
+  Q, ThrowCompletion, X, type ExpressionCompletion,
+} from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { PromiseObject } from './Promise.mts';
+
+/** https://tc39.es/ecma262/#sec-promise.prototype.catch */
+function PromiseProto_catch([onRejected = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let promise be the this value.
+  const promise = thisValue;
+  // 2. Return ? Invoke(promise, "then", « undefined, onRejected »).
+  return Q(Invoke(promise, Value('then'), [Value.undefined, onRejected]));
+}
+
+/** https://tc39.es/ecma262/#sec-promise.prototype.finally */
+function PromiseProto_finally([onFinally = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let promise be the this value.
+  const promise = thisValue;
+  // 2. If Type(promise) is not Object, throw a TypeError exception.
+  if (!(promise instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotATypeObject', 'Promise', promise);
+  }
+  // 3. Let C be ? SpeciesConstructor(promise, %Promise%).
+  const C = Q(SpeciesConstructor(promise, surroundingAgent.intrinsic('%Promise%')));
+  // 4. Assert: IsConstructor(C) is true.
+  Assert(IsConstructor(C) === Value.true);
+  let thenFinally;
+  let catchFinally;
+  // 5. If IsCallable(onFinally) is false, then
+  if (IsCallable(onFinally) === Value.false) {
+    // a. Let thenFinally be onFinally.
+    thenFinally = onFinally;
+    // b. Let catchFinally be onFinally.
+    catchFinally = onFinally;
+  } else { // 6. Else,
+    // a. Let thenFinallyClosure be a new Abstract Closure with parameters (value) that captures onFinally and C and performs the following steps when called:
+    const thenFinallyClosure = ([value = Value.undefined]: Arguments): ExpressionCompletion => {
+      // i. Let result be ? Call(onFinally, undefined).
+      const result = Q(Call(onFinally, Value.undefined));
+      // ii. Let promise be ? PromiseResolve(C, result).
+      const promiseInner = Q(PromiseResolve(C, result));
+      // iii. Let returnValue be a new Abstract Closure with no parameters that captures value and performs the following steps when called:
+      //   1. Return value.
+      const returnValue = () => value;
+      // iv. Let valueThunk be ! CreateBuiltinFunction(returnValue, 0, "", « »).
+      const valueThunk = X(CreateBuiltinFunction(returnValue, 0, Value(''), []));
+      // v. Return ? Invoke(promise, "then", « valueThunk »).
+      return Q(Invoke(promiseInner, Value('then'), [valueThunk]));
+    };
+    // b. Let thenFinally be ! CreateBuiltinFunction(thenFinallyClosure, 1, "", « »).
+    thenFinally = X(CreateBuiltinFunction(thenFinallyClosure, 1, Value(''), []));
+    // c. Let catchFinallyClosure be a new Abstract Closure with parameters (reason) that captures onFinally and C and performs the following steps when called:
+    const catchFinallyClosure = ([reason = Value.undefined]: Arguments): ExpressionCompletion => {
+      // i. Let result be ? Call(onFinally, undefined).
+      const result = Q(Call(onFinally, Value.undefined));
+      // ii. Let promise be ? PromiseResolve(C, result).
+      const promiseInner = Q(PromiseResolve(C, result));
+      // iii. Let throwReason be a new Abstract Closure with no parameters that captures reason and performs the following steps when called:
+      //   1. Return ThrowCompletion(reason).
+      const throwReason = () => ThrowCompletion(reason);
+      // iv. Let thrower be ! CreateBuiltinFunction(throwReason, 0, "", « »).
+      const thrower = X(CreateBuiltinFunction(throwReason, 0, Value(''), []));
+      // v. Return ? Invoke(promise, "then", « thrower »).
+      return Q(Invoke(promiseInner, Value('then'), [thrower]));
+    };
+    // d. Let catchFinally be ! CreateBuiltinFunction(catchFinallyClosure, 1, "", « »).
+    catchFinally = X(CreateBuiltinFunction(catchFinallyClosure, 1, Value(''), []));
+  }
+  // 7. Return ? Invoke(promise, "then", « thenFinally, catchFinally »).
+  return Q(Invoke(promise, Value('then'), [thenFinally, catchFinally]));
+}
+
+/** https://tc39.es/ecma262/#sec-promise.prototype.then */
+function PromiseProto_then([onFulfilled = Value.undefined, onRejected = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let promise be the this value.
+  const promise = thisValue as PromiseObject;
+  // 2. If IsPromise(promise) is false, throw a TypeError exception.
+  if (IsPromise(promise) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotATypeObject', 'Promise', promise);
+  }
+  // 3. Let C be ? SpeciesConstructor(promise, %Promise%).
+  const C = Q(SpeciesConstructor(promise, surroundingAgent.intrinsic('%Promise%')));
+  // 4. Let resultCapability be ? NewPromiseCapability(C).
+  const resultCapability = Q(NewPromiseCapability(C));
+  // 5. Return PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability).
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(promise));
+  return PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability);
+}
+
+export function bootstrapPromisePrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['catch', PromiseProto_catch, 1],
+    ['finally', PromiseProto_finally, 1],
+    ['then', PromiseProto_then, 2],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Promise');
+
+  realmRec.Intrinsics['%Promise.prototype.then%'] = X(Get(proto, Value('then'))) as FunctionObject;
+
+  realmRec.Intrinsics['%Promise.prototype%'] = proto;
+}

package/src/intrinsics/Proxy.mts

@@ -0,0 +1,100 @@
+import {
+  surroundingAgent,
+} from '../engine.mts';
+import {
+  Assert,
+  CreateBuiltinFunction,
+  CreateDataProperty,
+  OrdinaryObjectCreate,
+  ProxyCreate,
+  Realm,
+  isProxyExoticObject,
+  type BuiltinFunctionObject,
+  type ExoticObject,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  NullValue, ObjectValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import { assignProps } from './bootstrap.mts';
+
+export interface ProxyObject extends ExoticObject, BuiltinFunctionObject {
+  ProxyHandler: Value | NullValue;
+  ProxyTarget: ObjectValue | NullValue;
+}
+export interface RevocableProxyRevokeFunctionObject extends BuiltinFunctionObject {
+  RevocableProxy: ProxyObject | NullValue;
+}
+/** https://tc39.es/ecma262/#sec-proxy-target-handler */
+function ProxyConstructor(this: FunctionObject, [target = Value.undefined, handler = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext) {
+  // 1. f NewTarget is undefined, throw a TypeError exception.
+  if (NewTarget === Value.undefined) {
+    return surroundingAgent.Throw('TypeError', 'ConstructorNonCallable', this);
+  }
+  // 2. Return ? ProxyCreate(target, handler).
+  return ProxyCreate(target, handler);
+}
+
+/** https://tc39.es/ecma262/#sec-proxy-revocation-functions */
+function ProxyRevocationFunctions() {
+  // 1. Let F be the active function object.
+  const F = surroundingAgent.activeFunctionObject as RevocableProxyRevokeFunctionObject;
+  // 2. Let p be F.[[RevocableProxy]].
+  const p = F.RevocableProxy;
+  // 3. If p is null, return undefined.
+  if (p === Value.null) {
+    return Value.undefined;
+  }
+  // 4. Set F.[[RevocableProxy]] to null.
+  F.RevocableProxy = Value.null;
+  // 5. Assert: p is a Proxy object.
+  Assert(isProxyExoticObject(p));
+  // 6. Set p.[[ProxyTarget]] to null.
+  p.ProxyTarget = Value.null;
+  // 7. Set p.[[ProxyHandler]] to null.
+  p.ProxyHandler = Value.null;
+  // 8. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-proxy.revocable */
+function Proxy_revocable([target = Value.undefined, handler = Value.undefined]: Arguments): ExpressionCompletion {
+  // 1. Let p be ? ProxyCreate(target, handler).
+  const p = Q(ProxyCreate(target, handler));
+  /** https://tc39.es/ecma262/#sec-proxy-revocation-functions. */
+  const steps = ProxyRevocationFunctions;
+  // 3. Let length be the number of non-optional parameters of the function definition in Proxy Revocation Functions.
+  const length = 0;
+  // 4. Let revoker be ! CreateBuiltinFunction(steps, length, "", « [[RevocableProxy]] »).
+  const revoker = X(CreateBuiltinFunction(steps, length, Value(''), ['RevocableProxy'])) as RevocableProxyRevokeFunctionObject;
+  // 5. Set revoker.[[RevocableProxy]] to p.
+  revoker.RevocableProxy = p;
+  // 6. Let result be OrdinaryObjectCreate(%Object.prototype%).
+  const result = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  // 7. Perform ! CreateDataPropertyOrThrow(result, "proxy", p).
+  X(CreateDataProperty(result, Value('proxy'), p));
+  // 8. Perform ! CreateDataPropertyOrThrow(result, "revoke", revoker).
+  X(CreateDataProperty(result, Value('revoke'), revoker));
+  // 9. Return result.
+  return result;
+}
+
+export function bootstrapProxy(realmRec: Realm) {
+  const proxyConstructor = CreateBuiltinFunction(
+    ProxyConstructor,
+    2,
+    Value('Proxy'),
+    [],
+    realmRec,
+    undefined,
+    undefined,
+    Value.true,
+  );
+
+  assignProps(realmRec, proxyConstructor, [
+    ['revocable', Proxy_revocable, 2],
+  ]);
+
+  realmRec.Intrinsics['%Proxy%'] = proxyConstructor;
+}

package/src/intrinsics/Reflect.mts

@@ -0,0 +1,211 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Call,
+  Construct,
+  CreateArrayFromList,
+  CreateListFromArrayLike,
+  FromPropertyDescriptor,
+  IsCallable,
+  IsConstructor,
+  PrepareForTailCall,
+  Realm,
+  ToPropertyDescriptor,
+  ToPropertyKey,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import { ObjectValue, Value, type Arguments } from '../value.mts';
+import { Q } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-reflect.apply */
+function Reflect_apply([target = Value.undefined, thisArgument = Value.undefined, argumentsList = Value.undefined]: Arguments) {
+  // 1. If IsCallable(target) is false, throw a TypeError exception.
+  if (IsCallable(target) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', target);
+  }
+  // 2. Let args be ? CreateListFromArrayLike(argumentsList).
+  const args = Q(CreateListFromArrayLike(argumentsList));
+  // 3. Perform PrepareForTailCall().
+  PrepareForTailCall();
+  // 4. Return ? Call(target, thisArgument, args).
+  return Q(Call(target, thisArgument, args));
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.construct */
+function Reflect_construct([target = Value.undefined, argumentsList = Value.undefined, newTarget]: Arguments) {
+  // 1. If IsConstructor(target) is false, throw a TypeError exception.
+  if (IsConstructor(target) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAConstructor', target);
+  }
+  // 2. If newTarget is not present, set newTarget to target.
+  if (newTarget === undefined) {
+    newTarget = target;
+  } else if (IsConstructor(newTarget) === Value.false) { // 3. Else if IsConstructor(newTarget) is false, throw a TypeError exception.
+    return surroundingAgent.Throw('TypeError', 'NotAConstructor', newTarget);
+  }
+  // 4. Let args be ? CreateListFromArrayLike(argumentsList).
+  const args = Q(CreateListFromArrayLike(argumentsList));
+  // 5. Return ? Construct(target, args, newTarget).
+  return Q(Construct(target as FunctionObject, args, newTarget as FunctionObject));
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.defineproperty */
+function Reflect_defineProperty([target = Value.undefined, propertyKey = Value.undefined, attributes = Value.undefined]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(ToPropertyKey(propertyKey));
+  // 3. Let desc be ? ToPropertyDescriptor(attributes).
+  const desc = Q(ToPropertyDescriptor(attributes));
+  // 4. Return ? target.[[DefineOwnProperty]](key, desc).
+  return Q(target.DefineOwnProperty(key, desc));
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.deleteproperty */
+function Reflect_deleteProperty([target = Value.undefined, propertyKey = Value.undefined]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(ToPropertyKey(propertyKey));
+  // 3. Return ? target.[[Delete]](key).
+  return Q(target.Delete(key));
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.get */
+function Reflect_get([target = Value.undefined, propertyKey = Value.undefined, receiver]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(ToPropertyKey(propertyKey));
+  // 3. If receiver is not present, then
+  if (receiver === undefined) {
+    // a. Set receiver to target.
+    receiver = target;
+  }
+  // 4. Return ? target.[[Get]](key, receiver).
+  return Q(target.Get(key, receiver));
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.getownpropertydescriptor */
+function Reflect_getOwnPropertyDescriptor([target = Value.undefined, propertyKey = Value.undefined]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(ToPropertyKey(propertyKey));
+  // 3. Let desc be ? target.[[GetOwnProperty]](key).
+  const desc = Q(target.GetOwnProperty(key));
+  // 4. Return FromPropertyDescriptor(desc).
+  return FromPropertyDescriptor(desc);
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.getprototypeof */
+function Reflect_getPrototypeOf([target = Value.undefined]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. Return ? target.[[GetPrototypeOf]]().
+  return Q(target.GetPrototypeOf());
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.has */
+function Reflect_has([target = Value.undefined, propertyKey = Value.undefined]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(ToPropertyKey(propertyKey));
+  // 3. Return ? target.[[HasProperty]](key).
+  return Q(target.HasProperty(key));
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.isextensible */
+function Reflect_isExtensible([target = Value.undefined]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. Return ? target.[[IsExtensible]]().
+  return Q(target.IsExtensible());
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.ownkeys */
+function Reflect_ownKeys([target = Value.undefined]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. Let keys be ? target.[[OwnPropertyKeys]]().
+  const keys = Q(target.OwnPropertyKeys());
+  // 3. Return CreateArrayFromList(keys).
+  return CreateArrayFromList(keys);
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.preventextensions */
+function Reflect_preventExtensions([target = Value.undefined]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. Return ? target.[[PreventExtensions]]().
+  return Q(target.PreventExtensions());
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.set */
+function Reflect_set([target = Value.undefined, propertyKey = Value.undefined, V = Value.undefined, receiver]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(ToPropertyKey(propertyKey));
+  // 3. If receiver is not present, then
+  if (receiver === undefined) {
+    receiver = target;
+  }
+  // 4. Return ? target.[[Set]](key, V, receiver).
+  return Q(target.Set(key, V, receiver));
+}
+
+/** https://tc39.es/ecma262/#sec-reflect.setprototypeof */
+function Reflect_setPrototypeOf([target = Value.undefined, proto = Value.undefined]: Arguments) {
+  // 1. If Type(target) is not Object, throw a TypeError exception.
+  if (!(target instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', target);
+  }
+  // 2. If Type(proto) is not Object and proto is not null, throw a TypeError exception.
+  if (!(proto instanceof ObjectValue) && proto !== Value.null) {
+    return surroundingAgent.Throw('TypeError', 'ObjectPrototypeType');
+  }
+  // 3. Return ? target.[[SetPrototypeOf]](proto).
+  return Q(target.SetPrototypeOf(proto));
+}
+
+export function bootstrapReflect(realmRec: Realm) {
+  const reflect = bootstrapPrototype(realmRec, [
+    ['apply', Reflect_apply, 3],
+    ['construct', Reflect_construct, 2],
+    ['defineProperty', Reflect_defineProperty, 3],
+    ['deleteProperty', Reflect_deleteProperty, 2],
+    ['get', Reflect_get, 2],
+    ['getOwnPropertyDescriptor', Reflect_getOwnPropertyDescriptor, 2],
+    ['getPrototypeOf', Reflect_getPrototypeOf, 1],
+    ['has', Reflect_has, 2],
+    ['isExtensible', Reflect_isExtensible, 1],
+    ['ownKeys', Reflect_ownKeys, 1],
+    ['preventExtensions', Reflect_preventExtensions, 1],
+    ['set', Reflect_set, 3],
+    ['setPrototypeOf', Reflect_setPrototypeOf, 2],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Reflect');
+
+  realmRec.Intrinsics['%Reflect%'] = reflect;
+}

package/src/intrinsics/RegExp.mts

@@ -0,0 +1,103 @@
+import {
+  surroundingAgent,
+} from '../engine.mts';
+import {
+  Get,
+  IsRegExp,
+  Realm,
+  RegExpAlloc,
+  RegExpInitialize,
+  SameValue,
+  type FunctionObject,
+  type OrdinaryObject,
+} from '../abstract-ops/all.mts';
+import {
+  JSStringValue,
+  ObjectValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { Q, type ExpressionCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+export interface RegExpObject extends OrdinaryObject {
+  readonly OriginalSource: JSStringValue;
+  readonly OriginalFlags: JSStringValue;
+  readonly RegExpMatcher: (str: JSStringValue, index: number) => unknown;
+  readonly parsedPattern: ParseNode.RegExp.Pattern;
+}
+export function isRegExpObject(o: Value): o is RegExpObject {
+  return 'RegExpMatcher' in o;
+}
+/** https://tc39.es/ecma262/#sec-regexp-constructor */
+function RegExpConstructor([pattern = Value.undefined, flags = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let patternIsRegExp be ? IsRegExp(pattern).
+  const patternIsRegExp = Q(IsRegExp(pattern));
+  let newTarget;
+  // 2. If NewTarget is undefined, then
+  if (NewTarget === Value.undefined) {
+    // a. Let newTarget be the active function object.
+    newTarget = surroundingAgent.activeFunctionObject;
+    // b. If patternIsRegExp is true and flags is undefined, then
+    if (patternIsRegExp === Value.true && flags === Value.undefined) {
+      // i. Let patternConstructor be ? Get(pattern, "constructor").
+      const patternConstructor = Q(Get(pattern as ObjectValue, Value('constructor')));
+      // ii. If SameValue(newTarget, patternConstructor) is true, return pattern.
+      if (SameValue(newTarget, patternConstructor) === Value.true) {
+        return pattern;
+      }
+    }
+  } else { // 3. Else, let newTarget be NewTarget.
+    newTarget = NewTarget;
+  }
+  let P;
+  let F;
+  // 4. If Type(pattern) is Object and pattern has a [[RegExpMatcher]] internal slot, then
+  if (isRegExpObject(pattern)) {
+    // a. Let P be pattern.[[OriginalSource]].
+    P = pattern.OriginalSource;
+    // b. If flags is undefined, let F be pattern.[[OriginalFlags]].
+    if (flags === Value.undefined) {
+      F = pattern.OriginalFlags;
+    } else { // c. Else, let F be flags.
+      F = flags;
+    }
+  } else if (patternIsRegExp === Value.true) { // 5. Else if patternIsRegExp is true, then
+    // a. Else if patternIsRegExp is true, then
+    P = Q(Get(pattern as ObjectValue, Value('source')));
+    // b. If flags is undefined, then
+    if (flags === Value.undefined) {
+      // i. Let F be ? Get(pattern, "flags").
+      F = Q(Get(pattern as ObjectValue, Value('flags')));
+    } else { // c. Else, let F be flags.
+      F = flags;
+    }
+  } else { // 6. Else,
+    // a. Let P be pattern.
+    P = pattern;
+    // b. Let F be flags.
+    F = flags;
+  }
+  // 7. Let O be ? RegExpAlloc(newTarget).
+  const O = Q(RegExpAlloc(newTarget as FunctionObject));
+  // 8. Return ? RegExpInitialize(O, P, F).
+  return Q(RegExpInitialize(O, P, F));
+}
+
+/** https://tc39.es/ecma262/#sec-get-regexp-@@species */
+function RegExp_speciesGetter(_args: Arguments, { thisValue }: FunctionCallContext) {
+  return thisValue;
+}
+
+export function bootstrapRegExp(realmRec: Realm) {
+  const proto = realmRec.Intrinsics['%RegExp.prototype%'];
+
+  const cons = bootstrapConstructor(realmRec, RegExpConstructor, 'RegExp', 2, proto, [
+    [wellKnownSymbols.species, [RegExp_speciesGetter]],
+  ]);
+
+  realmRec.Intrinsics['%RegExp%'] = cons;
+}