@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/abstract-ops/regexp-objects.mts

@@ -0,0 +1,310 @@
+import {
+  Descriptor, Value, ObjectValue, BooleanValue, JSStringValue,
+  UndefinedValue,
+} from '../value.mts';
+import {
+  Q, ThrowCompletion, X, type ValueEvaluator,
+} from '../completion.mts';
+import { CompilePattern, CountLeftCapturingParensWithin, type RegExpRecord } from '../runtime-semantics/all.mts';
+import { ParsePattern } from '../parse.mts';
+import { isLineTerminator } from '../parser/Lexer.mts';
+import type { Mutable } from '../utils/language.mts';
+import type { RegExpObject } from '../intrinsics/RegExp.mts';
+import {
+  ArrayCreate,
+  Assert,
+  CreateArrayFromList,
+  CreateDataPropertyOrThrow,
+  DefinePropertyOrThrow,
+  OrdinaryCreateFromConstructor,
+  OrdinaryObjectCreate,
+  SameValue,
+  Set,
+  ToString,
+  F as toNumberValue,
+  type FunctionObject,
+} from './all.mts';
+import { surroundingAgent, Throw } from '#self';
+
+/** https://tc39.es/ecma262/#sec-regexpalloc */
+export function* RegExpAlloc(newTarget: FunctionObject): ValueEvaluator<RegExpObject> {
+  const obj = Q(yield* OrdinaryCreateFromConstructor(newTarget, '%RegExp.prototype%', ['RegExpMatcher', 'OriginalSource', 'OriginalFlags'])) as Mutable<RegExpObject>;
+  X(DefinePropertyOrThrow(obj, Value('lastIndex'), Descriptor({
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-regexpinitialize */
+export function* RegExpInitialize(obj: Mutable<RegExpObject>, pattern: Value, flags: Value) {
+  let P: JSStringValue;
+  // 1. If pattern is undefined, let P be the empty String.
+  if (pattern === Value.undefined) {
+    P = Value('');
+  } else { // 2. Else, let P be ? ToString(pattern).
+    P = Q(yield* ToString(pattern));
+  }
+  let F;
+  // 3. If flags is undefined, let F be the empty String.
+  if (flags === Value.undefined) {
+    F = Value('');
+  } else { // 4. Else, let F be ? ToString(flags).
+    F = Q(yield* ToString(flags));
+  }
+  const f = F.stringValue();
+  if (/^[dgimsuvy]*$/.test(f) === false) {
+    return Throw.SyntaxError('RegExp has invalid flags ($1)', f);
+  }
+  if (new globalThis.Set(f).size !== f.length) {
+    return Throw.SyntaxError('RegExp flags must not have duplicates ($1)', f);
+  }
+  const i = f.includes('i');
+  const m = f.includes('m');
+  const s = f.includes('s');
+  const u = f.includes('u');
+  const v = f.includes('v');
+
+  // 11. If u is true or v is true, then
+  //   a. Let patternText be StringToCodePoints(P).
+  // 12. Else,
+  //   a. Let patternText be the result of interpreting each of P's 16-bit elements as a Unicode BMP code point. UTF-16 decoding is not applied to the elements.
+  const patternText = P.stringValue();
+
+  const parseResult = ParsePattern(patternText, u, v);
+  if (Array.isArray(parseResult)) {
+    return ThrowCompletion(parseResult[0]);
+  }
+  obj.OriginalSource = P;
+  obj.OriginalFlags = F;
+  const capturingGroupsCount = CountLeftCapturingParensWithin(parseResult);
+  const rer: RegExpRecord = {
+    IgnoreCase: i,
+    Multiline: m,
+    DotAll: s,
+    Unicode: u,
+    UnicodeSets: v,
+    CapturingGroupsCount: capturingGroupsCount,
+  };
+  obj.RegExpRecord = rer;
+  obj.parsedPattern = parseResult;
+  obj.RegExpMatcher = CompilePattern(parseResult, rer);
+  Q(yield* Set(obj, Value('lastIndex'), toNumberValue(+0), Value.true));
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-regexpcreate */
+export function* RegExpCreate(P: Value, F: Value): ValueEvaluator<RegExpObject> {
+  const obj = Q(yield* RegExpAlloc(surroundingAgent.intrinsic('%RegExp%')));
+  return Q(yield* RegExpInitialize(obj, P, F));
+}
+
+/** https://tc39.es/ecma262/#sec-escaperegexppattern */
+export function EscapeRegExpPattern(P: JSStringValue, _F: Value) {
+  const source = P.stringValue();
+  if (source === '') {
+    return Value('(?:)');
+  }
+  let index = 0;
+  let escaped = '';
+  let inClass = false;
+  let isEscape = false;
+  while (index < source.length) {
+    const c = source[index];
+    switch (c) {
+      case '\\':
+        index += 1;
+        if (isLineTerminator(source[index])) {
+          // nothing
+        } else {
+          isEscape = !isEscape;
+          escaped += '\\';
+        }
+        break;
+      case '/':
+        index += 1;
+        if (inClass || isEscape) {
+          isEscape = false;
+          escaped += '/';
+        } else {
+          escaped += '\\/';
+        }
+        break;
+      case '[':
+        inClass = !isEscape;
+        index += 1;
+        escaped += '[';
+        break;
+      case ']':
+        inClass = !isEscape;
+        index += 1;
+        escaped += ']';
+        break;
+      case '\n':
+        index += 1;
+        escaped += '\\n';
+        break;
+      case '\r':
+        index += 1;
+        escaped += '\\r';
+        break;
+      case '\u2028':
+        index += 1;
+        escaped += '\\u2028';
+        break;
+      case '\u2029':
+        index += 1;
+        escaped += '\\u2029';
+        break;
+      default:
+        index += 1;
+        escaped += c;
+        break;
+    }
+    if (c !== '\\') {
+      isEscape = false;
+    }
+  }
+  return Value(escaped);
+}
+
+/** https://tc39.es/ecma262/#sec-getstringindex */
+export function GetStringIndex(S: JSStringValue, Input: readonly string[], e: number) {
+  // 1. Assert: Type(S) is String.
+  Assert(S instanceof JSStringValue);
+  // 2. Assert: Input is a List of the code points of S interpreted as a UTF-16 encoded string.
+  Assert(Array.isArray(Input));
+  // 3. Assert: e is an integer value ≥ 0.
+  Assert(e >= 0);
+  // 4. If S is the empty String, return 0.
+  if (S.stringValue() === '') {
+    return 0;
+  }
+  // 5. Let eUTF be the smallest index into S that corresponds to the character at element e of Input.
+  //    If e is greater than or equal to the number of elements in Input, then eUTF is the number of code units in S.
+  let eUTF = 0;
+  if (e >= Input.length) {
+    eUTF = S.stringValue().length;
+  } else {
+    for (let i = 0; i < e; i += 1) {
+      eUTF += Input[i].length;
+    }
+  }
+  // 6. Return eUTF.
+  return eUTF;
+}
+
+export interface MatchRecord {
+  readonly StartIndex: number;
+  readonly EndIndex: number;
+}
+/** https://tc39.es/ecma262/#sec-getmatchstring */
+export function GetMatchString(S: JSStringValue, match: MatchRecord) {
+  // 1. Assert: Type(S) is String.
+  Assert(S instanceof JSStringValue);
+  // 2. Assert: match is a Match Record.
+  Assert('StartIndex' in match && 'EndIndex' in match);
+  // 3. Assert: match.[[StartIndex]] is an integer value ≥ 0 and ≤ the length of S.
+  Assert(match.StartIndex >= 0 && match.StartIndex <= S.stringValue().length);
+  // 4. Assert: match.[[EndIndex]] is an integer value ≥ match.[[StartIndex]] and ≤ the length of S.
+  Assert(match.EndIndex >= match.StartIndex && match.EndIndex <= S.stringValue().length);
+  // 5. Return the portion of S between offset match.[[StartIndex]] inclusive and offset match.[[EndIndex]] exclusive.
+  return Value(S.stringValue().slice(match.StartIndex, match.EndIndex));
+}
+
+/** https://tc39.es/ecma262/#sec-getmatchindexpair */
+export function GetMatchIndexPair(S: JSStringValue, match: MatchRecord) {
+  // 1. Assert: Type(S) is String.
+  Assert(S instanceof JSStringValue);
+  // 2. Assert: match is a Match Record.
+  Assert('StartIndex' in match && 'EndIndex' in match);
+  // 3. Assert: match.[[StartIndex]] is an integer value ≥ 0 and ≤ the length of S.
+  Assert(match.StartIndex >= 0 && match.StartIndex <= S.stringValue().length);
+  // 4. Assert: match.[[EndIndex]] is an integer value ≥ match.[[StartIndex]] and ≤ the length of S.
+  Assert(match.EndIndex >= match.StartIndex && match.EndIndex <= S.stringValue().length);
+  // 1. Return CreateArrayFromList(« 𝔽(match.[[StartIndex]]), 𝔽(match.[[EndIndex]]) »).
+  return CreateArrayFromList([
+    toNumberValue(match.StartIndex),
+    toNumberValue(match.EndIndex),
+  ]);
+}
+
+/** https://tc39.es/ecma262/#sec-makematchindicesindexpairarray */
+export function MakeMatchIndicesIndexPairArray(S: JSStringValue, indices: readonly (MatchRecord | UndefinedValue)[], groupNames: readonly (JSStringValue | UndefinedValue)[], hasGroups: BooleanValue) {
+  // 1. Assert: Type(S) is String.
+  Assert(S instanceof JSStringValue);
+  // 2. Assert: indices is a List.
+  Assert(Array.isArray(indices));
+  // 3. Let n be the number of elements in indices.
+  const n = indices.length;
+  // 4. Assert: n < 2**32-1.
+  Assert(n < (2 ** 32) - 1);
+  // 5. Assert: groupNames is a List with _n_ - 1 elements.
+  Assert(Array.isArray(groupNames) && groupNames.length === n - 1);
+  // 6. NOTE: The groupNames List contains elements aligned with the indices List starting at indices[1].
+  // 7. Assert: Type(hasGroups) is Boolean.
+  Assert(hasGroups instanceof BooleanValue);
+  // 8. Set A to ! ArrayCreate(n).
+  // 9. Assert: The value of A's "length" property is n.
+  const array = X(ArrayCreate(n));
+  // 10. If hasGroups is true, then
+  let groups: ObjectValue | UndefinedValue;
+  if (hasGroups === Value.true) {
+    // a. Let groups be ! ObjectCreate(null).
+    groups = X(OrdinaryObjectCreate(Value.null));
+  } else { // 9. Else,
+    // b. Let groups be undefined.
+    groups = Value.undefined;
+  }
+  // 11. Perform ! CreateDataProperty(A, "groups", groups).
+  X(CreateDataPropertyOrThrow(array, Value('groups'), groups));
+  // 12. For each integer i such that i ≥ 0 and i < n, do
+  for (let i = 0; i < n; i += 1) {
+    // a. Let matchIndices be indices[i].
+    const matchIndices = indices[i];
+    // b. If matchIndices is not undefined, then
+    let matchIndicesArray;
+    if (matchIndices !== Value.undefined) {
+      // i. Let matchIndicesArray be ! GetMatchIndexPair(S, matchIndices).
+      matchIndicesArray = X(GetMatchIndexPair(S, matchIndices as MatchRecord));
+    } else { // c. Else,
+      // i. Let matchIndicesArray be undefined.
+      matchIndicesArray = Value.undefined;
+    }
+    // d. Perform ! CreateDataProperty(A, ! ToString(𝔽(i)), matchIndicesArray).
+    X(CreateDataPropertyOrThrow(array, X(ToString(toNumberValue(i))), matchIndicesArray));
+    // e. If i > 0 and groupNames[i - 1] is not undefined, then
+    if (i > 0 && groupNames[i - 1] !== Value.undefined) {
+      // i. Perform ! CreateDataProperty(groups, groupNames[i - 1], matchIndicesArray).
+      X(CreateDataPropertyOrThrow(groups as ObjectValue, groupNames[i - 1] as JSStringValue, matchIndicesArray));
+    }
+  }
+  // 13. Return A.
+  return array;
+}
+
+/** https://tc39.es/ecma262/#sec-regexphasflag */
+export function RegExpHasFlag(R: Value, codeUnit: string) {
+  // 1. If Type(R) is not Object, throw a TypeError exception.
+  if (!(R instanceof ObjectValue)) {
+    return Throw.TypeError('$1 is not a RegExp object', R);
+  }
+  // 2. If R does not have an [[OriginalFlags]] internal slot, then
+  if (!('OriginalFlags' in R)) {
+    // a. If SameValue(R, %RegExp.prototype%) is true, return undefined.
+    if (SameValue(R, surroundingAgent.intrinsic('%RegExp.prototype%'))) {
+      return Value.undefined;
+    }
+    // b. Otherwise, throw a TypeError exception.
+    return Throw.TypeError('$1 is not a RegExp object', R);
+  }
+  // 3. Let flags be R.[[OriginalFlags]].
+  const flags = (R as RegExpObject).OriginalFlags.stringValue();
+  // 4. If flags contains codeUnit, return true.
+  if (flags.includes(codeUnit)) {
+    return Value.true;
+  }
+  // 5. Return false.
+  return Value.false;
+}

package/src/abstract-ops/shadow-realm.mts

@@ -0,0 +1,216 @@
+import { isArray } from '../utils/language.mts';
+import { captureStack } from '../utils/stack.mts';
+import { setErrorHostInternalSlot } from '../intrinsics/Error.mts';
+import type { ErrorObject } from '../intrinsics/Error.mts';
+import {
+  Assert, Call, Construct, CopyNameAndLength, CreateBuiltinFunction, DeclarativeEnvironmentRecord, EnvironmentRecord, EvalDeclarationInstantiation, Evaluate, ExecutionContext, Get, GetFunctionRealm, HasOwnProperty, HostEnsureCanCompileStrings, HostLoadImportedModule, IsCallable, isErrorObject, isModuleNamespaceObject, JSStringValue, MakeBasicObject, NewPromiseCapability, NormalCompletion, ObjectValue, Parser, PerformPromiseThen, Q, RequireInternalSlot, surroundingAgent, Throw, ThrowCompletion, Value, wrappedParse, X, type Arguments, type BuiltinFunctionObject, type ExoticObject, type FunctionObject, type Mutable, type PlainCompletion, type Realm, type ValueEvaluator,
+} from '#self';
+
+/** https://tc39.es/proposal-shadowrealm/#table-internal-slots-of-wrapped-function-exotic-objects */
+export interface WrappedFunctionExoticObject extends BuiltinFunctionObject, ExoticObject {
+  readonly WrappedTargetFunction: FunctionObject;
+  readonly Realm: Realm;
+}
+
+export function isWrappedFunctionExoticObject(value: Value): value is WrappedFunctionExoticObject {
+  return 'WrappedTargetFunction' in value;
+}
+
+/** https://tc39.es/proposal-shadowrealm/#sec-wrapped-function-exotic-objects-call-thisargument-argumentslist */
+function* WrappedFunction_Call(this: WrappedFunctionExoticObject, thisArgument: Value, argumentList: Arguments): ValueEvaluator {
+  const F = this;
+  const callerContext = surroundingAgent.runningExecutionContext;
+  const calleeContext = PrepareForWrappedFunctionCall(F);
+  Assert(surroundingAgent.runningExecutionContext === calleeContext);
+  const result = yield* OrdinaryWrappedFunctionCall(F, thisArgument, argumentList);
+  surroundingAgent.executionContextStack.pop(calleeContext);
+  Assert(surroundingAgent.runningExecutionContext === callerContext);
+  return Q(result);
+}
+
+/** https://tc39.es/proposal-shadowrealm/#sec-create-type-error-copy */
+export function CreateTypeErrorCopy(realmRecord: Realm, non_spec_evalRealm: Realm, originalError: Value): ObjectValue {
+  realmRecord.HostDefined.attachingInspectorReportError?.(non_spec_evalRealm, originalError);
+  let message = 'An error occurred in a ShadowRealm.';
+  const newError = X(Construct(realmRecord.Intrinsics['%TypeError%'], [Value(message)])) as ErrorObject;
+  if (originalError instanceof ObjectValue) {
+    if (isErrorObject(originalError)) {
+      newError.HostDefinedFormattedStack = originalError.HostDefinedFormattedStack;
+      newError.HostDefinedStack = originalError.HostDefinedStack;
+      newError.HostDefinedMessage = originalError.HostDefinedMessage;
+      newError.HostDefinedMessageString = originalError.HostDefinedMessageString;
+    } else {
+      const S = captureStack();
+      if (originalError.properties.has('message')) {
+        const messageProp = originalError.properties.get('message');
+        if (messageProp && messageProp.Value && messageProp.Value instanceof JSStringValue) {
+          message = messageProp.Value.stringValue();
+        }
+      }
+      X(setErrorHostInternalSlot(newError, S, message));
+    }
+  }
+  return newError;
+}
+
+/** https://tc39.es/proposal-shadowrealm/#sec-ordinary-wrapped-function-call */
+export function* OrdinaryWrappedFunctionCall(F: WrappedFunctionExoticObject, thisArgument: Value, argumentList: Arguments): ValueEvaluator {
+  const target = F.WrappedTargetFunction;
+  Assert(IsCallable(target));
+  const callerRealm = F.Realm;
+
+  // Note: Any exception objects produced after this point are associated with callerRealm.
+  const targetRealm = Q(GetFunctionRealm(target));
+  const wrappedArgs: Value[] = [];
+  for (const arg of argumentList.values()) {
+    const wrappedValue = Q(yield* GetWrappedValue(targetRealm, arg));
+    wrappedArgs.push(wrappedValue);
+  }
+  const wrappedThisArgument = Q(yield* GetWrappedValue(targetRealm, thisArgument));
+  const result = yield* Call(target, wrappedThisArgument, wrappedArgs);
+  if (result instanceof Value || result instanceof NormalCompletion) {
+    return Q(yield* GetWrappedValue(callerRealm, result instanceof Value ? result : result.Value));
+  } else {
+    const copiedError = CreateTypeErrorCopy(callerRealm, targetRealm, result.Value);
+    return ThrowCompletion(copiedError);
+  }
+}
+
+/** https://tc39.es/proposal-shadowrealm/#sec-prepare-for-wrapped-function-call */
+export function PrepareForWrappedFunctionCall(F: WrappedFunctionExoticObject) {
+  const calleeContext = new ExecutionContext();
+  calleeContext.Function = F;
+  const calleeRealm = F.Realm;
+  calleeContext.Realm = calleeRealm;
+  calleeContext.ScriptOrModule = Value.null;
+  surroundingAgent.executionContextStack.push(calleeContext);
+  // 9. NOTE: Any exception objects produced after this point are associated with calleeRealm.
+  return calleeContext;
+}
+
+/** https://tc39.es/proposal-shadowrealm/#sec-wrappedfunctioncreate */
+export function* WrappedFunctionCreate(callerRealm: Realm, Target: FunctionObject) {
+  const internalSlotsList = ['WrappedTargetFunction', 'Call', 'Realm', 'Prototype', 'Extensible'];
+  const wrapped = MakeBasicObject(internalSlotsList) as Mutable<WrappedFunctionExoticObject>;
+  wrapped.Prototype = callerRealm.Intrinsics['%Function.prototype%'];
+  wrapped.Call = WrappedFunction_Call;
+  wrapped.WrappedTargetFunction = Target;
+  wrapped.Realm = callerRealm;
+  const result = yield* CopyNameAndLength(wrapped, Target);
+  if (result instanceof ThrowCompletion) {
+    return Throw.TypeError('Cannot create a ShadowRealm wrapped function on $1', Target);
+  }
+  return wrapped;
+}
+
+/** https://tc39.es/proposal-shadowrealm/#sec-performshadowrealmeval */
+export function* PerformShadowRealmEval(sourceText: string, callerRealm: Realm, evalRealm: Realm): ValueEvaluator {
+  Q(yield* HostEnsureCanCompileStrings(evalRealm, [], sourceText, false));
+  const script = wrappedParse({ source: sourceText }, (p) => p.scope.with({
+    newTarget: false,
+    superProperty: false,
+    superCall: false,
+  }, () => p.parseScript()));
+  const scriptId = surroundingAgent.addDynamicParsedSource(surroundingAgent.currentRealmRecord, sourceText, script);
+  if (isArray(script)) {
+    Parser.decorateSyntaxErrorWithScriptId(script[0], scriptId);
+    return ThrowCompletion(script[0]);
+  }
+  if (!script.ScriptBody) {
+    return Value.undefined;
+  }
+
+  const body = script.ScriptBody;
+  const strictEval = script.strict;
+  const evalContext = GetShadowRealmContext(evalRealm, strictEval);
+  evalContext.HostDefined ??= {};
+  evalContext.HostDefined.scriptId = scriptId;
+  // TODO: spec bug? dynamic import leak
+  // evalContext.ScriptOrModule = scriptRec;
+  const lexEnv = evalContext.LexicalEnvironment;
+  // TODO: spec bug?
+  Assert(lexEnv instanceof DeclarativeEnvironmentRecord);
+  const varEnv = evalContext.VariableEnvironment;
+  surroundingAgent.executionContextStack.push(evalContext);
+  let result: PlainCompletion<Value | void> = yield* EvalDeclarationInstantiation(body, varEnv, lexEnv, null, strictEval);
+  if (result instanceof NormalCompletion) {
+    result = yield* Evaluate(body);
+  }
+  if (result === undefined || (result instanceof NormalCompletion && result.Value === undefined)) {
+    result = NormalCompletion(Value.undefined);
+  }
+  surroundingAgent.executionContextStack.pop(evalContext);
+  if (result instanceof ThrowCompletion) {
+    const copiedError = CreateTypeErrorCopy(callerRealm, evalRealm, result.Value);
+    return ThrowCompletion(copiedError);
+  }
+  return Q(yield* GetWrappedValue(callerRealm, X(result) || Value.undefined));
+}
+
+/** https://tc39.es/proposal-shadowrealm/#sec-shadowrealmimportvalue */
+export function ShadowRealmImportValue(specifierString: JSStringValue, exportNameString: JSStringValue, callerRealm: Realm, evalRealm: Realm): Value {
+  const evalContext = GetShadowRealmContext(evalRealm, true);
+  const innerCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  surroundingAgent.executionContextStack.push(evalContext);
+  const referrer = evalContext.Realm;
+  HostLoadImportedModule(referrer, {
+    Specifier: specifierString.value,
+    Phase: 'evaluation',
+    Attributes: [],
+    ImportedNames: 'all',
+  }, undefined, { data: innerCapability });
+  surroundingAgent.executionContextStack.pop(evalContext);
+  const onFullfilled = CreateBuiltinFunction(function* onFullfilled([exports = Value.undefined]) {
+    Assert(isModuleNamespaceObject(exports));
+    const f = surroundingAgent.activeFunctionObject as FunctionObject;
+    const string = exportNameString;
+    const hasOwn = Q(yield* HasOwnProperty(exports, string));
+    if (hasOwn === Value.false) {
+      return Throw.TypeError('Module $1 does not have an export named $2', specifierString, string);
+    }
+    const value = Q(yield* Get(exports, string));
+    const realm = f.Realm;
+    return Q(yield* GetWrappedValue(realm, value));
+  }, 1, Value(''), [], callerRealm);
+  const onRejected = CreateBuiltinFunction((([error = Value.undefined]) => {
+    // 1. Let realmRecord be the function's associated Realm Record.
+    const realmRecord = callerRealm;
+    const copiedError = CreateTypeErrorCopy(realmRecord, evalRealm, error);
+    return ThrowCompletion(copiedError);
+  }), 1, Value(''), [], callerRealm);
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  return PerformPromiseThen(innerCapability.Promise, onFullfilled, onRejected, promiseCapability);
+}
+
+/** https://tc39.es/proposal-shadowrealm/#sec-getwrappedvalue */
+export function* GetWrappedValue(callerRealm: Realm, value: Value): ValueEvaluator {
+  if (value instanceof ObjectValue) {
+    if (!IsCallable(value)) {
+      return Throw.TypeError('Only primitive values and functions can be passed across the ShadowRealm boundary, but $1 is an object', value);
+    }
+    return Q(yield* WrappedFunctionCreate(callerRealm, value));
+  }
+  return value;
+}
+
+/** https://tc39.es/proposal-shadowrealm/#sec-validateshadowrealmobject */
+export function ValidateShadowRealmObject(O: Value): PlainCompletion<void> {
+  Q(RequireInternalSlot(O, 'ShadowRealm'));
+}
+
+/** https://tc39.es/proposal-shadowrealm/#sec-getshadowrealmcontext */
+export function GetShadowRealmContext(shadowRealmRecord: Realm, strictEval: boolean): ExecutionContext {
+  const lexEnv = new DeclarativeEnvironmentRecord(shadowRealmRecord.GlobalEnv);
+  let varEnv: EnvironmentRecord = shadowRealmRecord.GlobalEnv;
+  if (strictEval) {
+    varEnv = lexEnv;
+  }
+  const context = new ExecutionContext();
+  context.Function = Value.null;
+  context.Realm = shadowRealmRecord;
+  context.ScriptOrModule = Value.null;
+  context.VariableEnvironment = varEnv;
+  context.LexicalEnvironment = lexEnv;
+  context.PrivateEnvironment = null;
+  return context;
+}

package/src/abstract-ops/shared-arraybuffer.mts

@@ -0,0 +1,8 @@
+export function sharedArrayBufferNotSupported(): never {
+  throw new Error('SharedArrayBuffer is not supported');
+}
+
+/** https://tc39.es/ecma262/#sec-isgrowablesharedarraybuffer */
+export function IsGrowableSharedArrayBuffer(_object: unknown): boolean {
+  return false;
+}