@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/PromisePrototype.mts

@@ -0,0 +1,126 @@
+import {
+  ObjectValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import {
+  Q, X,
+} from '../completion.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { PromiseObject } from './Promise.mts';
+import { surroundingAgent } from '#self';
+import {
+  Assert,
+  Call,
+  CreateBuiltinFunction,
+  Get,
+  Invoke,
+  IsCallable,
+  IsConstructor,
+  IsPromise,
+  NewPromiseCapability,
+  PerformPromiseThen,
+  PromiseResolve,
+  Realm,
+  SpeciesConstructor,
+  Throw,
+  type FunctionObject,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-promise.prototype.catch */
+function* PromiseProto_catch([onRejected = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let promise be the this value.
+  const promise = thisValue;
+  // 2. Return ? Invoke(promise, "then", « undefined, onRejected »).
+  return Q(yield* Invoke(promise, Value('then'), [Value.undefined, onRejected]));
+}
+
+/** https://tc39.es/ecma262/#sec-promise.prototype.finally */
+function* PromiseProto_finally([onFinally = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 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 Throw.TypeError('$1 is not a $2 object', promise, 'Promise');
+  }
+  // 3. Let C be ? SpeciesConstructor(promise, %Promise%).
+  const constructor = Q(yield* SpeciesConstructor(promise, surroundingAgent.intrinsic('%Promise%')));
+  // 4. Assert: IsConstructor(C) is true.
+  Assert(IsConstructor(constructor));
+  let thenFinally;
+  let catchFinally;
+  // 5. If IsCallable(onFinally) is false, then
+  if (!IsCallable(onFinally)) {
+    // 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 = function* thenFinallyClosure([value = Value.undefined]: Arguments): ValueEvaluator {
+      // i. Let result be ? Call(onFinally, undefined).
+      const result = Q(yield* Call(onFinally, Value.undefined));
+      // ii. Let promise be ? PromiseResolve(C, result).
+      const promiseInner = Q(yield* PromiseResolve(constructor, 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(yield* Invoke(promiseInner, Value('then'), [valueThunk]));
+    };
+    // b. Let thenFinally be ! CreateBuiltinFunction(thenFinallyClosure, 1, "", « »).
+    thenFinally = X(CreateBuiltinFunction(thenFinallyClosure, 1, Value(''), ['HostCapturedValues']));
+    // NON-SPEC
+    thenFinally.HostCapturedValues = [onFinally];
+    // 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 = function* catchFinallyClosure([reason = Value.undefined]: Arguments): ValueEvaluator {
+      // i. Let result be ? Call(onFinally, undefined).
+      const result = Q(yield* Call(onFinally, Value.undefined));
+      // ii. Let promise be ? PromiseResolve(C, result).
+      const promiseInner = Q(yield* PromiseResolve(constructor, result));
+      // iii. Let throwReason be a new Abstract Closure with no parameters that captures reason and performs the following steps when called:
+      //   1. Return Throw(reason).
+      const throwReason = () => Throw(reason);
+      // iv. Let thrower be ! CreateBuiltinFunction(throwReason, 0, "", « »).
+      const thrower = X(CreateBuiltinFunction(throwReason, 0, Value(''), []));
+      // v. Return ? Invoke(promise, "then", « thrower »).
+      return Q(yield* Invoke(promiseInner, Value('then'), [thrower]));
+    };
+    // d. Let catchFinally be ! CreateBuiltinFunction(catchFinallyClosure, 1, "", « »).
+    catchFinally = X(CreateBuiltinFunction(catchFinallyClosure, 1, Value(''), ['HostCapturedValues']));
+    // NON-SPEC
+    catchFinally.HostCapturedValues = [onFinally];
+  }
+  // 7. Return ? Invoke(promise, "then", « thenFinally, catchFinally »).
+  return Q(yield* 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 Throw.TypeError('$1 is not a $2 object', promise, 'Promise');
+  }
+  // 3. Let C be ? SpeciesConstructor(promise, %Promise%).
+  const constructor = Q(yield* SpeciesConstructor(promise, surroundingAgent.intrinsic('%Promise%')));
+  // 4. Let resultCapability be ? NewPromiseCapability(C).
+  const resultCapability = Q(yield* NewPromiseCapability(constructor));
+  // 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,101 @@
+import {
+  NullValue, ObjectValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { Q, X, type ValueCompletion } from '../completion.mts';
+import { assignProps } from './bootstrap.mts';
+import {
+  surroundingAgent,
+} from '#self';
+import {
+  Assert,
+  CreateBuiltinFunction,
+  CreateDataProperty,
+  markBuiltinFunctionAsConstructor,
+  OrdinaryObjectCreate,
+  ProxyCreate,
+  Realm,
+  Throw,
+  type BuiltinFunctionObject,
+  type ExoticObject,
+  type FunctionObject,
+} from '#self';
+
+export interface ProxyObject extends ExoticObject, BuiltinFunctionObject {
+  ProxyHandler: Value | NullValue;
+  ProxyTarget: ObjectValue | NullValue;
+}
+export function isProxyExoticObject(O: Value): O is ProxyObject {
+  return 'ProxyHandler' in O;
+}
+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 Throw.TypeError('Proxy cannot be invoked without new');
+  }
+  // 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): ValueCompletion {
+  // 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(
+    markBuiltinFunctionAsConstructor(ProxyConstructor),
+    2,
+    Value('Proxy'),
+    [],
+    realmRec,
+  );
+
+  assignProps(realmRec, proxyConstructor, [
+    ['revocable', Proxy_revocable, 2],
+  ]);
+
+  realmRec.Intrinsics['%Proxy%'] = proxyConstructor;
+}

package/src/intrinsics/Reflect.mts

@@ -0,0 +1,211 @@
+import { ObjectValue, Value, type Arguments } from '../value.mts';
+import { Q } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import {
+  Call,
+  Construct,
+  CreateArrayFromList,
+  CreateListFromArrayLike,
+  FromPropertyDescriptor,
+  IsCallable,
+  IsConstructor,
+  PrepareForTailCall,
+  Realm,
+  Throw,
+  ToPropertyDescriptor,
+  ToPropertyKey,
+  type FunctionObject,
+} from '#self';
+
+/** 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)) {
+    return Throw.TypeError('$1 is not a function', target);
+  }
+  // 2. Let args be ? CreateListFromArrayLike(argumentsList).
+  const args = Q(yield* CreateListFromArrayLike(argumentsList));
+  // 3. Perform PrepareForTailCall().
+  PrepareForTailCall();
+  // 4. Return ? Call(target, thisArgument, args).
+  return Q(yield* 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)) {
+    return Throw.TypeError('$1 is not a constructor', target);
+  }
+  // 2. If newTarget is not present, set newTarget to target.
+  if (newTarget === undefined) {
+    newTarget = target;
+  } else if (!IsConstructor(newTarget)) { // 3. Else if IsConstructor(newTarget) is false, throw a TypeError exception.
+    return Throw.TypeError('$1 is not a constructor', newTarget);
+  }
+  // 4. Let args be ? CreateListFromArrayLike(argumentsList).
+  const args = Q(yield* CreateListFromArrayLike(argumentsList));
+  // 5. Return ? Construct(target, args, newTarget).
+  return Q(yield* Construct(target, 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 Throw.TypeError('$1 is not an object', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(yield* ToPropertyKey(propertyKey));
+  // 3. Let desc be ? ToPropertyDescriptor(attributes).
+  const desc = Q(yield* ToPropertyDescriptor(attributes));
+  // 4. Return ? target.[[DefineOwnProperty]](key, desc).
+  return Q(yield* 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 Throw.TypeError('$1 is not an object', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(yield* ToPropertyKey(propertyKey));
+  // 3. Return ? target.[[Delete]](key).
+  return Q(yield* 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 Throw.TypeError('$1 is not an object', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(yield* 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(yield* 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 Throw.TypeError('$1 is not an object', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(yield* ToPropertyKey(propertyKey));
+  // 3. Let desc be ? target.[[GetOwnProperty]](key).
+  const desc = Q(yield* 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 Throw.TypeError('$1 is not an object', target);
+  }
+  // 2. Return ? target.[[GetPrototypeOf]]().
+  return Q(yield* 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 Throw.TypeError('$1 is not an object', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(yield* ToPropertyKey(propertyKey));
+  // 3. Return ? target.[[HasProperty]](key).
+  return Q(yield* 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 Throw.TypeError('$1 is not an object', target);
+  }
+  // 2. Return ? target.[[IsExtensible]]().
+  return Q(yield* 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 Throw.TypeError('$1 is not an object', target);
+  }
+  // 2. Let keys be ? target.[[OwnPropertyKeys]]().
+  const keys = Q(yield* 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 Throw.TypeError('$1 is not an object', target);
+  }
+  // 2. Return ? target.[[PreventExtensions]]().
+  return Q(yield* 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 Throw.TypeError('$1 is not an object', target);
+  }
+  // 2. Let key be ? ToPropertyKey(propertyKey).
+  const key = Q(yield* ToPropertyKey(propertyKey));
+  // 3. If receiver is not present, then
+  if (receiver === undefined) {
+    receiver = target;
+  }
+  // 4. Return ? target.[[Set]](key, V, receiver).
+  return Q(yield* 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 Throw.TypeError('$1 is not an object', 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 Throw.TypeError('Object prototype must be an object or null');
+  }
+  // 3. Return ? target.[[SetPrototypeOf]](proto).
+  return Q(yield* 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,166 @@
+import {
+  JSStringValue,
+  ObjectValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import {
+  isDecimalDigit, isLineTerminator, isWhitespace,
+} from '../parser/Lexer.mts';
+import { isAsciiLetter, isControlEscape, isSyntaxCharacter } from '../parser/RegExpParser.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { UnicodeEscape } from './JSON.mts';
+import {
+  surroundingAgent,
+} from '#self';
+import {
+  Get,
+  IsRegExp,
+  Realm,
+  RegExpAlloc,
+  RegExpInitialize,
+  SameValue,
+  type FunctionObject,
+  type OrdinaryObject,
+
+  Assert, isLeadingSurrogate, isTrailingSurrogate, StringToCodePoints, UTF16EncodeCodePoint, type CodePoint, type RegExpMatcher, type RegExpRecord,
+  Throw,
+} from '#self';
+
+export interface RegExpObject extends OrdinaryObject {
+  readonly OriginalSource: JSStringValue;
+  readonly OriginalFlags: JSStringValue;
+  readonly RegExpMatcher: RegExpMatcher;
+  readonly RegExpRecord: RegExpRecord;
+  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): ValueEvaluator {
+  // 1. Let patternIsRegExp be ? IsRegExp(pattern).
+  const patternIsRegExp = Q(yield* 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(yield* Get(pattern as ObjectValue, Value('constructor')));
+      // ii. If SameValue(newTarget, patternConstructor) is true, return pattern.
+      if (SameValue(newTarget, patternConstructor)) {
+        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(yield* 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(yield* 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(yield* RegExpAlloc(newTarget as FunctionObject));
+  // 8. Return ? RegExpInitialize(O, P, F).
+  return Q(yield* RegExpInitialize(O, P, F));
+}
+
+/** https://tc39.es/ecma262/#sec-regexp.escape */
+function* RegExp_escape([S = Value.undefined]: Arguments) {
+  if (!(S instanceof JSStringValue)) {
+    return Throw.TypeError('$1 is not a string', S);
+  }
+  let escaped = '';
+  const cpList = StringToCodePoints(S.stringValue());
+  for (const cp of cpList) {
+    if (escaped === '' && (isDecimalDigit(String.fromCodePoint(cp)) || isAsciiLetter(cp))) {
+      const numericValue = cp;
+      const hex = numericValue.toString(16);
+      Assert(hex.length === 2);
+      escaped += `\u{005C}x${hex}`;
+    } else {
+      escaped += EncodeForRegExpEscape(cp);
+    }
+  }
+  return Value(escaped);
+}
+
+const table67: Record<number, string> = {
+  9: 't',
+  10: 'n',
+  11: 'v',
+  12: 'f',
+  13: 'r',
+};
+function EncodeForRegExpEscape(cp: CodePoint) {
+  const ch = String.fromCharCode(cp);
+  if (cp === 0x002F || isSyntaxCharacter(ch)) {
+    return `\u{005C}${UTF16EncodeCodePoint(cp)}`;
+  } else if (isControlEscape(cp)) {
+    return `\u{005C}${table67[cp]!}`;
+  }
+  const otherPunctuators = ",-=<>#&!%:;@~'`\u{0022}";
+  const toEscape = StringToCodePoints(otherPunctuators);
+  if (toEscape.includes(cp) || isWhitespace(ch) || isLineTerminator(ch) || isLeadingSurrogate(cp) || isTrailingSurrogate(cp)) {
+    const cpNum = cp;
+    if (cpNum <= 0xFF) {
+      const hex = cpNum.toString(16);
+      return `\u{005C}x${hex.padStart(2, '0')}`;
+    }
+    let escaped = '';
+    const codeUnits = UTF16EncodeCodePoint(cp);
+    for (const cu of codeUnits) {
+      escaped += UnicodeEscape(cu);
+    }
+    return escaped;
+  }
+  return UTF16EncodeCodePoint(cp);
+}
+
+/** 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]],
+    ['escape', RegExp_escape, 1],
+  ]);
+
+  realmRec.Intrinsics['%RegExp%'] = cons;
+}