@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/DisposableStack.mts

@@ -0,0 +1,41 @@
+import { Value, UndefinedValue, type Arguments, type FunctionCallContext } from '../value.mts';
+import { Q } from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import type { DisposableResourceRecord } from '../abstract-ops/disposable-operations.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import {
+  OrdinaryCreateFromConstructor,
+  Realm,
+  Throw,
+  type OrdinaryObject,
+} from '#self';
+
+export interface DisposableStackObject extends OrdinaryObject {
+  DisposableState: 'pending' | 'disposed';
+  DisposableResourceStack: DisposableResourceRecord[];
+}
+
+/** https://tc39.es/ecma262/#sec-disposablestack */
+function* DisposableStackConstructor(_args: Arguments, { NewTarget }: FunctionCallContext) {
+  if (NewTarget instanceof UndefinedValue) {
+    return Throw.TypeError('$1 cannot be invoked without new', Value('DisposableStack'));
+  }
+  const disposableStack = Q(yield* OrdinaryCreateFromConstructor(
+    NewTarget,
+    '%DisposableStack.prototype%',
+    ['DisposableState', 'DisposableResourceStack'],
+  )) as Mutable<DisposableStackObject>;
+  disposableStack.DisposableState = 'pending';
+  disposableStack.DisposableResourceStack = [];
+  return disposableStack;
+}
+
+export function bootstrapDisposableStack(realmRec: Realm) {
+  realmRec.Intrinsics['%DisposableStack%'] = bootstrapConstructor(
+    realmRec,
+    DisposableStackConstructor,
+    'DisposableStack',
+    0,
+    realmRec.Intrinsics['%DisposableStack.prototype%'],
+  );
+}

package/src/intrinsics/DisposableStackPrototype.mts

@@ -0,0 +1,103 @@
+import { Descriptor, Value, wellKnownSymbols, type Arguments, type FunctionCallContext } from '../value.mts';
+import { NormalCompletion, Q, X, type ValueCompletion } from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import { AddDisposableResource, DisposeResources } from '../abstract-ops/disposable-operations.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { DisposableStackObject } from './DisposableStack.mts';
+import {
+  Call,
+  CreateBuiltinFunction,
+  IsCallable,
+  OrdinaryCreateFromConstructor,
+  Realm,
+  RequireInternalSlot,
+  surroundingAgent,
+  Throw,
+  type ValueEvaluator,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-disposablestack.prototype.adopt */
+function* DisposableStackProto_adopt(
+  [value = Value.undefined, onDispose = Value.undefined]: Arguments,
+  { thisValue }: FunctionCallContext,
+) {
+  Q(RequireInternalSlot(thisValue, 'DisposableState'));
+  const disposableStack = thisValue as DisposableStackObject;
+  if (disposableStack.DisposableState === 'disposed') return Throw.ReferenceError('Object is disposed');
+  if (!IsCallable(onDispose)) return Throw.TypeError('$1 is not a function', onDispose);
+  const closure = function* closure(): ValueEvaluator {
+    return Q(yield* Call(onDispose, Value.undefined, [value]));
+  };
+  const func = CreateBuiltinFunction(closure, 0, Value(''), []);
+  Q(yield* AddDisposableResource(disposableStack.DisposableResourceStack, Value.undefined, 'sync-dispose', func));
+  return value;
+}
+
+/** https://tc39.es/ecma262/#sec-disposablestack.prototype.defer */
+function* DisposableStackProto_defer(
+  [onDispose = Value.undefined]: Arguments,
+  { thisValue }: FunctionCallContext,
+) {
+  Q(RequireInternalSlot(thisValue, 'DisposableState'));
+  const disposableStack = thisValue as DisposableStackObject;
+  if (disposableStack.DisposableState === 'disposed') return Throw.ReferenceError('Object is disposed');
+  if (!IsCallable(onDispose)) return Throw.TypeError('$1 is not a function', onDispose);
+  Q(yield* AddDisposableResource(disposableStack.DisposableResourceStack, Value.undefined, 'sync-dispose', onDispose));
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-disposablestack.prototype.dispose */
+function* DisposableStackProto_dispose(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  Q(RequireInternalSlot(thisValue, 'DisposableState'));
+  const disposableStack = thisValue as DisposableStackObject;
+  if (disposableStack.DisposableState === 'disposed') return Value.undefined;
+  disposableStack.DisposableState = 'disposed';
+  return Q(yield* DisposeResources(disposableStack.DisposableResourceStack, NormalCompletion(Value.undefined)));
+}
+
+/** https://tc39.es/ecma262/#sec-get-disposablestack.prototype.disposed */
+function DisposableStackProto_disposed(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  Q(RequireInternalSlot(thisValue, 'DisposableState'));
+  const disposableStack = thisValue as DisposableStackObject;
+  if (disposableStack.DisposableState === 'disposed') return Value.true;
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-disposablestack.prototype.move */
+function* DisposableStackProto_move(_args: Arguments, { thisValue }: FunctionCallContext) {
+  Q(RequireInternalSlot(thisValue, 'DisposableState'));
+  const disposableStack = thisValue as DisposableStackObject;
+  if (disposableStack.DisposableState === 'disposed') return Throw.ReferenceError('Object is disposed');
+  const newDisposableStack = Q(yield* OrdinaryCreateFromConstructor(
+    surroundingAgent.intrinsic('%DisposableStack%'),
+    '%DisposableStack.prototype%',
+    ['DisposableState', 'DisposableResourceStack'],
+  )) as Mutable<DisposableStackObject>;
+  newDisposableStack.DisposableState = 'pending';
+  newDisposableStack.DisposableResourceStack = disposableStack.DisposableResourceStack;
+  disposableStack.DisposableResourceStack = [];
+  disposableStack.DisposableState = 'disposed';
+  return newDisposableStack;
+}
+
+/** https://tc39.es/ecma262/#sec-disposablestack.prototype.use */
+function* DisposableStackProto_use([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  Q(RequireInternalSlot(thisValue, 'DisposableState'));
+  const disposableStack = thisValue as DisposableStackObject;
+  if (disposableStack.DisposableState === 'disposed') return Throw.ReferenceError('Object is disposed');
+  Q(yield* AddDisposableResource(disposableStack.DisposableResourceStack, value, 'sync-dispose'));
+  return value;
+}
+
+export function bootstrapDisposableStackPrototype(realmRec: Realm) {
+  const prototype = bootstrapPrototype(realmRec, [
+    ['adopt', DisposableStackProto_adopt, 2],
+    ['defer', DisposableStackProto_defer, 1],
+    ['dispose', DisposableStackProto_dispose, 0],
+    ['disposed', [DisposableStackProto_disposed]],
+    ['move', DisposableStackProto_move, 0],
+    ['use', DisposableStackProto_use, 1],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'DisposableStack');
+  X(prototype.DefineOwnProperty(wellKnownSymbols.dispose, X(prototype.GetOwnProperty(Value('dispose'))) as Descriptor));
+  realmRec.Intrinsics['%DisposableStack.prototype%'] = prototype;
+}

package/src/intrinsics/Error.mts

@@ -0,0 +1,106 @@
+import {
+  Descriptor,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+  type ObjectValue,
+  type UndefinedValue,
+} from '../value.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import {
+  captureStack,
+  callSiteToErrorStack,
+} from '../utils/stack.mts';
+import { type CallSite, CallFrame } from '../utils/stack.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import {
+  DefinePropertyOrThrow,
+  OrdinaryCreateFromConstructor,
+  InstallErrorCause,
+  ToString,
+  type FunctionObject,
+  IsError,
+  Realm,
+  Call,
+  JSStringValue,
+  type PlainEvaluator,
+} from '#self';
+
+export interface ErrorObject extends ObjectValue {
+  ErrorData: never;
+  /** Show a clickable stack in the devtools */
+  HostDefinedStack: readonly (CallSite | CallFrame)[] | UndefinedValue;
+  /** Show an error message that allows ECMAScript values to be interleaved with host error messages in the devtools */
+  HostDefinedMessage: readonly (string | Value)[] | UndefinedValue;
+  HostDefinedFormattedStack: string | UndefinedValue;
+  HostDefinedMessageString: string | UndefinedValue;
+}
+
+export const ErrorHostInternalSlots = Object.freeze([
+  'HostDefinedStack',
+  'HostDefinedMessage',
+  'HostDefinedFormattedStack',
+  'HostDefinedMessageString',
+] as const);
+
+export function* setErrorHostInternalSlot(O: ErrorObject, { nativeStack, stack }: ReturnType<typeof captureStack>, errorStringPredefined?: string): PlainEvaluator {
+  const errorString = errorStringPredefined ?? (Q(yield* Call(surroundingAgent.intrinsic('%Error.prototype.toString%'), O)) as JSStringValue).stringValue();
+  const errorStack = callSiteToErrorStack(stack, nativeStack);
+  O.HostDefinedStack = stack;
+  O.HostDefinedFormattedStack = errorStack;
+  O.HostDefinedMessageString = errorString;
+}
+
+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',
+    ...ErrorHostInternalSlots,
+  ])) 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));
+
+  Q(yield* setErrorHostInternalSlot(O, captureStack()));
+
+  // 5. Return O.
+  return O;
+}
+
+/** https://tc39.es/proposal-is-error/#sec-error.iserror */
+function Error_isError([value = Value.undefined]: 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,100 @@
+import {
+  JSStringValue,
+  ObjectValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+  type UndefinedValue,
+} from '../value.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import { isErrorObject } from './Error.mts';
+import {
+  surroundingAgent,
+} from '#self';
+import {
+  Assert,
+  Get,
+  SetterThatIgnoresPrototypeProperties,
+  ToString,
+  type BuiltinFunctionObject,
+  Realm,
+  Throw,
+} from '#self';
+
+/** 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 Throw.TypeError('this value $1 is not an object', 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_stack_getter(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator<JSStringValue | UndefinedValue> {
+  const error = thisValue;
+  if (!(error instanceof ObjectValue)) {
+    return Throw.TypeError('this value $1 is not an object', error);
+  }
+  if (!isErrorObject(error)) {
+    return Value.undefined;
+  }
+  // 4. Return an implementation-defined string that represents the stack trace of error.
+  Assert(typeof error.HostDefinedFormattedStack === 'string');
+  return Value(error.HostDefinedMessageString + error.HostDefinedFormattedStack);
+}
+
+/** https://tc39.es/proposal-error-stack-accessor/#sec-set-error.prototype.stack */
+function* ErrorProto_stack_setter(args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator<UndefinedValue> {
+  const [value = Value.undefined] = args;
+
+  const error = thisValue;
+  if (!(error instanceof ObjectValue)) {
+    return Throw.TypeError('this value $1 is not an object', error);
+  }
+  if (!(value instanceof JSStringValue)) {
+    return Throw.TypeError('stack property must be set to a string value, but got $1', value);
+  }
+  Q(yield* SetterThatIgnoresPrototypeProperties(thisValue, surroundingAgent.intrinsic('%Error.prototype%'), Value('stack'), value));
+  return Value.undefined;
+}
+
+export function bootstrapErrorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['toString', ErrorProto_toString, 0],
+    ['message', Value('')],
+    ['name', Value('Error')],
+    ['stack', [ErrorProto_stack_getter, ErrorProto_stack_setter]],
+  ], 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,69 @@
+import { HostMakeJobCallback } from '../execution-context/Job.mts';
+import { type JobCallbackRecord } from '../execution-context/Job.mts';
+import {
+  UndefinedValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { Q } from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import {
+  IsCallable, OrdinaryCreateFromConstructor,
+  type BuiltinFunctionObject, type FunctionObject, type OrdinaryObject,
+  Realm,
+  Throw,
+} from '#self';
+
+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 Throw.TypeError('FinalizationRegistry cannot be invoked without new');
+  }
+  // 2. If IsCallable(cleanupCallback) is false, throw a TypeError exception.
+  if (!IsCallable(cleanupCallback)) {
+    return Throw.TypeError('$1 is not a function', 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,110 @@
+import {
+  Value, type Arguments, type FunctionCallContext, BooleanValue,
+} from '../value.mts';
+import { Q } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { FinalizationRegistryCell, FinalizationRegistryObject } from './FinalizationRegistry.mts';
+import { surroundingAgent } from '#self';
+import {
+  CanBeHeldWeakly,
+  CleanupFinalizationRegistry,
+  IsCallable,
+  RequireInternalSlot,
+  SameValue,
+  type FunctionObject,
+  Realm,
+  Throw,
+} from '#self';
+
+/** 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 Throw.TypeError('$1 is not a function', 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)) {
+    return Throw.TypeError('$1 is not an object or a symbol', target);
+  }
+  // 4. If SameValue(target, heldValue), throw a TypeError exception.
+  if (SameValue(target, heldValue)) {
+    return Throw.TypeError('heldValue $1 matches target', heldValue);
+  }
+  // 5. If CanBeHeldWeakly(unregisterToken) is false, then
+  if (!CanBeHeldWeakly(unregisterToken)) {
+    // a. If unregisterToken is not undefined, throw a TypeError exception.
+    if (unregisterToken !== Value.undefined) {
+      return Throw.TypeError('$1 is not an object or a symbol', 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)) {
+    return Throw.TypeError('$1 is not an object or a symbol', 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)) {
+      // 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 { Q, type ValueEvaluator } from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../utils/language.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import {
+  Assert,
+  SameValue,
+  OrdinaryObjectCreate,
+  CreateIteratorResultObject,
+  type OrdinaryObject,
+  Realm,
+} from '#self';
+
+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))) {
+        // 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,24 @@
+import { Q } from '../completion.mts';
+import { CreateDynamicFunction } from '../runtime-semantics/all.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import {
+  type Arguments, type ValueEvaluator, type FunctionCallContext, type FunctionObject, type Realm,
+  Value,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-function-p1-p2-pn-body */
+function* FunctionConstructor(args: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  const bodyArg = args[args.length - 1] || Value('');
+  args = args.slice(0, -1) as Arguments;
+  // 1. Let C be the active function object.
+  const activeFunc = 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(activeFunc, NewTarget, 'normal', args, bodyArg));
+}
+
+export function bootstrapFunction(realmRec: Realm) {
+  const cons = bootstrapConstructor(realmRec, FunctionConstructor, 'Function', 1, realmRec.Intrinsics['%Function.prototype%'], []);
+  realmRec.Intrinsics['%Function%'] = cons;
+}