@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/intrinsics/RegExpStringIteratorPrototype.mts

@@ -0,0 +1,81 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  BooleanValue, JSStringValue, NullValue, ObjectValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import {
+  Assert,
+  CreateIteratorFromClosure,
+  GeneratorResume,
+  ToString,
+  ToLength,
+  Get,
+  Set,
+  Yield,
+  F, R as MathematicalValue,
+  Realm,
+  type GeneratorObject,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import type { YieldEvaluator } from '../evaluator.mts';
+import { RegExpExec, AdvanceStringIndex } from './RegExpPrototype.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+const kRegExpStringIteratorPrototype = Value('%RegExpStringIteratorPrototype%');
+
+/** https://tc39.es/ecma262/#sec-createregexpstringiterator */
+export function CreateRegExpStringIterator(R: ObjectValue, S: JSStringValue, global: BooleanValue, fullUnicode: BooleanValue): ExpressionCompletion<GeneratorObject> {
+  // 1. Assert: Type(S) is String.
+  Assert(S instanceof JSStringValue);
+  // 2. Assert: Type(global) is Boolean.
+  Assert(global instanceof BooleanValue);
+  // 3. Assert: Type(fullUnicode) is Boolean.
+  Assert(fullUnicode instanceof BooleanValue);
+  // 4. Let closure be a new Abstract Closure with no parameters that captures R, S, global, and fullUnicode and performs the following steps when called:
+  const closure = function* closure(): YieldEvaluator {
+    // a. Repeat,
+    while (true) {
+      // i. Let match be ? RegExpExec(R, S).
+      const match = Q(RegExpExec(R, S));
+      // ii. If match is null, return undefined.
+      if (match instanceof NullValue) {
+        return Value.undefined;
+      }
+      // iii. If global is false, then
+      if (global === Value.false) {
+        // 1. Perform ? Yield(match).
+        Q(yield* Yield(match));
+        // 2. Return undefined.
+        return Value.undefined;
+      }
+      // iv. Let matchStr be ? ToString(? Get(match, "0")).
+      const matchStr = Q(ToString(Q(Get(match, Value('0')))));
+      // v. If matchStr is the empty String, then
+      if (matchStr.stringValue() === '') {
+        // i. Let thisIndex be ℝ(? ToLength(? Get(R, "lastIndex"))).
+        const thisIndex = MathematicalValue(Q(ToLength(Q(Get(R, Value('lastIndex'))))));
+        // ii. Let nextIndex be ! AdvanceStringIndex(S, thisIndex, fullUnicode).
+        const nextIndex = X(AdvanceStringIndex(S, thisIndex, fullUnicode));
+        // iii. Perform ? Set(R, "lastIndex", 𝔽(nextIndex), true).
+        Q(Set(R, Value('lastIndex'), F(nextIndex), Value.true));
+      }
+      // vi. Perform ? Yield(match).
+      Q(yield* Yield(match));
+    }
+  };
+  // 4. Return ! CreateIteratorFromClosure(closure, "%RegExpStringIteratorPrototype%", %RegExpStringIteratorPrototype%).
+  return X(CreateIteratorFromClosure(closure, kRegExpStringIteratorPrototype, surroundingAgent.intrinsic('%RegExpStringIteratorPrototype%')));
+}
+
+/** https://tc39.es/ecma262/#sec-%regexpstringiteratorprototype%.next */
+function RegExpStringIteratorPrototype_next(_args: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Return ? GeneratorResume(this value, empty, "%RegExpStringIteratorPrototype%").
+  return Q(GeneratorResume(thisValue, undefined, kRegExpStringIteratorPrototype));
+}
+
+export function bootstrapRegExpStringIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', RegExpStringIteratorPrototype_next, 0],
+  ], realmRec.Intrinsics['%IteratorPrototype%'], 'RegExp String Iterator');
+
+  realmRec.Intrinsics['%RegExpStringIteratorPrototype%'] = proto;
+}

package/src/intrinsics/Set.mts

@@ -0,0 +1,72 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Call,
+  Get,
+  GetIterator,
+  IsCallable,
+  IteratorStepValue,
+  OrdinaryCreateFromConstructor,
+  Realm,
+  type FunctionObject,
+  type OrdinaryObject,
+} from '../abstract-ops/all.mts';
+import {
+  UndefinedValue, Value, wellKnownSymbols, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { IfAbruptCloseIterator, Q } from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+export interface SetObject extends OrdinaryObject {
+  readonly SetData: (Value | undefined)[];
+}
+/** https://tc39.es/ecma262/#sec-set-iterable */
+function SetConstructor(this: FunctionObject, [iterable = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext) {
+  // 1. If NewTarget is undefined, throw a TypeError exception.
+  if (NewTarget instanceof UndefinedValue) {
+    return surroundingAgent.Throw('TypeError', 'ConstructorNonCallable', this);
+  }
+  // 2. Let set be ? OrdinaryCreateFromConstructor(NewTarget, "%Set.prototype%", « [[SetData]] »).
+  const set = Q(OrdinaryCreateFromConstructor(NewTarget, '%Set.prototype%', ['SetData'])) as Mutable<SetObject>;
+  // 3. Set set.[[SetData]] to a new empty List.
+  set.SetData = [];
+  // 4. If iterable is either undefined or null, return set.
+  if (iterable === Value.undefined || iterable === Value.null) {
+    return set;
+  }
+  // 5. Let adder be ? Get(set, "add").
+  const adder = Q(Get(set, Value('add')));
+  // 6. If IsCallable(adder) is false, throw a TypeError exception.
+  if (IsCallable(adder) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', adder);
+  }
+  // 7. Let iteratorRecord be ? GetIterator(iterable).
+  const iteratorRecord = Q(GetIterator(iterable, 'sync'));
+  // 8. Repeat,
+  while (true) {
+    // a. Let next be ? IteratorStepValue(iteratorRecord).
+    const next = Q(IteratorStepValue(iteratorRecord));
+    // b. If next is false, return set.
+    if (next === 'done') {
+      return set;
+    }
+    // d. Let status be Call(adder, set, « next »).
+    const status = Call(adder, set, [next]);
+    // e. IfAbruptCloseIterator(status, iteratorRecord).
+    IfAbruptCloseIterator(status, iteratorRecord);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-get-set-@@species */
+function Set_speciesGetter(_args: Arguments, { thisValue }: FunctionCallContext) {
+  // Return the this value.
+  return thisValue;
+}
+
+export function bootstrapSet(realmRec: Realm) {
+  const setConstructor = bootstrapConstructor(realmRec, SetConstructor, 'Set', 0, realmRec.Intrinsics['%Set.prototype%'], [
+    [wellKnownSymbols.species, [Set_speciesGetter]],
+  ]);
+
+  realmRec.Intrinsics['%Set%'] = setConstructor;
+}

package/src/intrinsics/SetIteratorPrototype.mts

@@ -0,0 +1,77 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Assert,
+  CreateArrayFromList,
+  CreateIteratorFromClosure,
+  GeneratorResume,
+  Realm,
+  RequireInternalSlot,
+  Yield,
+  type GeneratorObject,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import {
+  Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import type { YieldEvaluator } from '../evaluator.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { SetObject } from './Set.mts';
+
+const kSetIteratorPrototype = Value('%SetIteratorPrototype%');
+
+/** https://tc39.es/ecma262/#sec-createsetiterator */
+export function CreateSetIterator(set: Value, kind: 'key+value' | 'value'): ExpressionCompletion<GeneratorObject> {
+  // 1. Assert: kind is key+value or value.
+  Assert(kind === 'key+value' || kind === 'value');
+  // 2. Perform ? RequireInternalSlot(set, [[SetData]]).
+  Q(RequireInternalSlot(set, 'SetData'));
+  // 3. Let closure be a new Abstract Closure with no parameters that captures set and kind and performs the following steps when called:
+  const closure = function* closure(): YieldEvaluator {
+    // a. Let index be 0.
+    let index = 0;
+    // b. Let entries be the List that is set.[[SetData]].
+    const entries = (set as SetObject).SetData;
+    // c. Let numEntries be the number of elements of entries.
+    let numEntries = entries.length;
+    // d. Repeat, while index < numEntries,
+    while (index < numEntries) {
+      // i. Let e be entries[index].
+      const e = entries[index];
+      // ii. Set index to index + 1.
+      index += 1;
+      // iii. If e is not empty, then
+      if (e !== undefined) {
+        // 1. If kind is key+value, then
+        if (kind === 'key+value') {
+          // a. Perform ? Yield(! CreateArrayFromList(« e, e »)).
+          Q(yield* Yield(X(CreateArrayFromList([e, e]))));
+        } else { // 2. Else,
+          // a. Assert: kind is value.
+          Assert(kind === 'value');
+          // b. Perform ? Yield(e).
+          Q(yield* Yield(e));
+        }
+      }
+      // iv. Set numEntries to the number of elements of entries.
+      numEntries = entries.length;
+    }
+    // e. Return undefined.
+    return Value.undefined;
+  };
+  // 4. Return ! CreateIteratorFromClosure(closure, "%SetIteratorPrototype%", %SetIteratorPrototype%).
+  return X(CreateIteratorFromClosure(closure, kSetIteratorPrototype, surroundingAgent.intrinsic('%SetIteratorPrototype%')));
+}
+
+/** https://tc39.es/ecma262/#sec-%setiteratorprototype%.next */
+function SetIteratorPrototype_next(_args: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Return ? GeneratorResume(this value, empty, "%SetIteratorPrototype%").
+  return Q(GeneratorResume(thisValue, undefined, kSetIteratorPrototype));
+}
+
+export function bootstrapSetIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', SetIteratorPrototype_next, 0],
+  ], realmRec.Intrinsics['%IteratorPrototype%'], 'Set Iterator');
+
+  realmRec.Intrinsics['%SetIteratorPrototype%'] = proto;
+}

package/src/intrinsics/SetPrototype.mts

@@ -0,0 +1,191 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Call,
+  F,
+  IsCallable,
+  RequireInternalSlot,
+  SameValueZero, R,
+  Realm,
+} from '../abstract-ops/all.mts';
+import {
+  Descriptor,
+  NumberValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import { CreateSetIterator } from './SetIteratorPrototype.mts';
+import type { SetObject } from './Set.mts';
+
+/** https://tc39.es/ecma262/#sec-set.prototype.add */
+function SetProto_add([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let S be the this value.
+  const S = thisValue as SetObject;
+  // 2. Perform ? RequireInternalSlot(S, [[SetData]]).
+  Q(RequireInternalSlot(S, 'SetData'));
+  // 3. Let entries be the List that is S.[[SetData]].
+  const entries = S.SetData;
+  // 4. For each e that is an element of entries, do
+  for (const e of entries) {
+    // a. For each e that is an element of entries, do
+    if (e !== undefined && SameValueZero(e, value) === Value.true) {
+      // i. Return S.
+      return S;
+    }
+  }
+  // 5. If value is -0𝔽, set value to +0𝔽.
+  if (value instanceof NumberValue && Object.is(R(value), -0)) {
+    value = F(+0);
+  }
+  // 6. Append value as the last element of entries.
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(S));
+  entries.push(value);
+  // 7. Return S.
+  return S;
+}
+
+/** https://tc39.es/ecma262/#sec-set.prototype.clear */
+function SetProto_clear(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let S be the this value.
+  const S = thisValue as SetObject;
+  // 2. Perform ? RequireInternalSlot(S, [[SetData]]).
+  Q(RequireInternalSlot(S, 'SetData'));
+  // 3. Let entries be the List that is S.[[SetData]].
+  const entries = S.SetData;
+  // 4. For each e that is an element of entries, do
+  if (entries.length) {
+    Q(surroundingAgent.debugger_tryTouchDuringPreview(S));
+  }
+  for (let i = 0; i < entries.length; i += 1) {
+    // a. Replace the element of entries whose value is e with an element whose value is empty.
+    entries[i] = undefined;
+  }
+  // 5. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-set.prototype.delete */
+function SetProto_delete([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let S be the this value.
+  const S = thisValue as SetObject;
+  // 2. Perform ? RequireInternalSlot(S, [[SetData]]).
+  Q(RequireInternalSlot(S, 'SetData'));
+  // 3. Let entries be the List that is S.[[SetData]].
+  const entries = S.SetData;
+  // 4. For each e that is an element of entries, do
+  for (let i = 0; i < entries.length; i += 1) {
+    const e = entries[i];
+    // a. If e is not empty and SameValueZero(e, value) is true, then
+    if (e !== undefined && SameValueZero(e, value) === Value.true) {
+      // i. Replace the element of entries whose value is e with an element whose value is empty.
+      Q(surroundingAgent.debugger_tryTouchDuringPreview(S));
+      entries[i] = undefined;
+      // ii. Return true.
+      return Value.true;
+    }
+  }
+  // 5. Return false.
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-set.prototype.entries */
+function SetProto_entries(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let S be the this value.
+  const S = thisValue;
+  // 2. Return ? CreateSetIterator(S, key+value).
+  return Q(CreateSetIterator(S, 'key+value'));
+}
+
+/** https://tc39.es/ecma262/#sec-set.prototype.foreach */
+function SetProto_forEach([callbackfn = Value.undefined, thisArg = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let S be the this value.
+  const S = thisValue as SetObject;
+  // 2. Perform ? RequireInternalSlot(S, [[SetData]]).
+  Q(RequireInternalSlot(S, 'SetData'));
+  // 3. If IsCallable(callbackfn) is false, throw a TypeError exception
+  if (IsCallable(callbackfn) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', callbackfn);
+  }
+  // 4. Let entries be the List that is S.[[SetData]].
+  const entries = S.SetData;
+  // 5. For each element _e_ of _entries_, do
+  for (const e of entries) {
+    // a. If e is not empty, then
+    if (e !== undefined) {
+      // i. Perform ? Call(callbackfn, thisArg, « e, e, S »).
+      Q(Call(callbackfn, thisArg, [e, e, S]));
+    }
+  }
+  // 6. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-set.prototype.has */
+function SetProto_has([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let S be the this value.
+  const S = thisValue as SetObject;
+  // 2. Perform ? RequireInternalSlot(S, [[SetData]]).
+  Q(RequireInternalSlot(S, 'SetData'));
+  // 3. Let entries be the List that is S.[[SetData]].
+  const entries = S.SetData;
+  // 4. Let entries be the List that is S.[[SetData]].
+  for (const e of entries) {
+    // a. If e is not empty and SameValueZero(e, value) is true, return true.
+    if (e !== undefined && SameValueZero(e, value) === Value.true) {
+      return Value.true;
+    }
+  }
+  // 5. Return false.
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-get-set.prototype.size */
+function SetProto_sizeGetter(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let S be the this value.
+  const S = thisValue as SetObject;
+  // 2. Perform ? RequireInternalSlot(S, [[SetData]]).
+  Q(RequireInternalSlot(S, 'SetData'));
+  // 3. Let entries be the List that is S.[[SetData]].
+  const entries = S.SetData;
+  // 4. Let count be 0.
+  let count = 0;
+  // 5. For each e that is an element of entries, do
+  for (const e of entries) {
+    // a. If e is not empty, set count to count + 1
+    if (e !== undefined) {
+      count += 1;
+    }
+  }
+  // 6. Return 𝔽(count).
+  return F(count);
+}
+
+/** https://tc39.es/ecma262/#sec-set.prototype.values */
+function SetProto_values(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let S be the this value.
+  const S = thisValue;
+  // 2. Return ? CreateSetIterator(S, value).
+  return Q(CreateSetIterator(S, 'value'));
+}
+
+export function bootstrapSetPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['add', SetProto_add, 1],
+    ['clear', SetProto_clear, 0],
+    ['delete', SetProto_delete, 1],
+    ['entries', SetProto_entries, 0],
+    ['forEach', SetProto_forEach, 1],
+    ['has', SetProto_has, 1],
+    ['size', [SetProto_sizeGetter]],
+    ['values', SetProto_values, 0],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Set');
+
+  const valuesFunc = X(proto.GetOwnProperty(Value('values'))) as Descriptor;
+  X(proto.DefineOwnProperty(Value('keys'), valuesFunc));
+  X(proto.DefineOwnProperty(wellKnownSymbols.iterator, valuesFunc));
+
+  realmRec.Intrinsics['%Set.prototype%'] = proto;
+}

package/src/intrinsics/String.mts

@@ -0,0 +1,134 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  BooleanValue,
+  JSStringValue,
+  NullValue,
+  ObjectValue,
+  SymbolValue,
+  UndefinedValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  Assert,
+  Get,
+  GetPrototypeFromConstructor,
+  IsIntegralNumber,
+  StringCreate,
+  SymbolDescriptiveString,
+  LengthOfArrayLike,
+  ToNumber,
+  ToObject,
+  ToString,
+  ToUint16,
+  F, R,
+  type ExoticObject,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { UTF16EncodeCodePoint } from '../static-semantics/all.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+export interface StringObject extends ExoticObject {
+  readonly StringData: JSStringValue;
+  Prototype: ObjectValue | NullValue;
+  Extensible: BooleanValue;
+}
+/** https://tc39.es/ecma262/#sec-string-constructor-string-value */
+function StringConstructor([value]: Arguments, { NewTarget }: FunctionCallContext): ExpressionCompletion {
+  let s;
+  if (value === undefined) {
+    s = Value('');
+  } else {
+    if (NewTarget === Value.undefined && value instanceof SymbolValue) {
+      return X(SymbolDescriptiveString(value));
+    }
+    s = Q(ToString(value));
+  }
+  if (NewTarget instanceof UndefinedValue) {
+    return s;
+  }
+  return X(StringCreate(s, Q(GetPrototypeFromConstructor(NewTarget, '%String.prototype%'))));
+}
+
+/** https://tc39.es/ecma262/#sec-string.fromcharcode */
+function String_fromCharCode(codeUnits: Arguments): ExpressionCompletion {
+  const length = codeUnits.length;
+  const elements = [];
+  let nextIndex = 0;
+  while (nextIndex < length) {
+    const next = codeUnits[nextIndex];
+    const nextCU = Q(ToUint16(next));
+    elements.push(nextCU);
+    nextIndex += 1;
+  }
+  const result = elements.reduce((previous, current) => previous + String.fromCharCode(R(current)), '');
+  return Value(result);
+}
+
+/** https://tc39.es/ecma262/#sec-string.fromcodepoint */
+function String_fromCodePoint(codePoints: Arguments) {
+  // 1. Let result be the empty String.
+  let result = '';
+  // 2. For each element next of codePoints, do
+  for (const next of codePoints) {
+    // a. Let nextCP be ? ToNumber(next).
+    const nextCP = Q(ToNumber(next));
+    // b. If IsIntegralNumber(nextCP) is false, throw a RangeError exception.
+    if (X(IsIntegralNumber(nextCP)) === Value.false) {
+      return surroundingAgent.Throw('RangeError', 'StringCodePointInvalid', next);
+    }
+    // c. If ℝ(nextCP) < 0 or ℝ(nextCP) > 0x10FFFF, throw a RangeError exception.
+    if (R(nextCP) < 0 || R(nextCP) > 0x10FFFF) {
+      return surroundingAgent.Throw('RangeError', 'StringCodePointInvalid', nextCP);
+    }
+    // d. Set result to the string-concatenation of result and UTF16EncodeCodePoint(ℝ(nextCP)).
+    result += UTF16EncodeCodePoint(R(nextCP));
+  }
+  // 3. Assert: If codePoints is empty, then result is the empty String.
+  Assert(!(codePoints.length === 0) || result.length === 0);
+  // 4. Return result.
+  return Value(result);
+}
+
+/** https://tc39.es/ecma262/#sec-string.raw */
+function String_raw([template = Value.undefined, ...substitutions]: Arguments): ExpressionCompletion {
+  const numberOfSubstitutions = substitutions.length;
+  const cooked = Q(ToObject(template));
+  const raw = Q(ToObject(Q(Get(cooked, Value('raw')))));
+  const literalSegments = Q(LengthOfArrayLike(raw));
+  if (literalSegments <= 0) {
+    return Value('');
+  }
+  // Not sure why the spec uses a List, but this is really just a String.
+  const stringElements = [];
+  let nextIndex = 0;
+  while (true) {
+    const nextKey = X(ToString(F(nextIndex)));
+    const nextSeg = Q(ToString(Q(Get(raw, nextKey))));
+    stringElements.push(nextSeg.stringValue());
+    if (nextIndex + 1 === literalSegments) {
+      return Value(stringElements.join(''));
+    }
+    let next;
+    if (nextIndex < numberOfSubstitutions) {
+      next = substitutions[nextIndex];
+    } else {
+      next = Value('');
+    }
+    const nextSub = Q(ToString(next));
+    stringElements.push(nextSub.stringValue());
+    nextIndex += 1;
+  }
+}
+
+export function bootstrapString(realmRec: Realm) {
+  const stringConstructor = bootstrapConstructor(realmRec, StringConstructor, 'String', 1, realmRec.Intrinsics['%String.prototype%'], [
+    ['fromCharCode', String_fromCharCode, 1],
+    ['fromCodePoint', String_fromCodePoint, 1],
+    ['raw', String_raw, 1],
+  ]);
+
+  realmRec.Intrinsics['%String%'] = stringConstructor;
+}

package/src/intrinsics/StringIteratorPrototype.mts

@@ -0,0 +1,25 @@
+import {
+  GeneratorResume,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { Q } from '../completion.mts';
+import {
+  Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+const kStringIteratorPrototype = Value('%StringIteratorPrototype%');
+
+/** https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next */
+function StringIteratorPrototype_next(_args: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Return ? GeneratorResume(this value, empty, "%StringIteratorPrototype%").
+  return Q(GeneratorResume(thisValue, undefined, kStringIteratorPrototype));
+}
+
+export function bootstrapStringIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', StringIteratorPrototype_next, 0],
+  ], realmRec.Intrinsics['%IteratorPrototype%'], 'String Iterator');
+
+  realmRec.Intrinsics['%StringIteratorPrototype%'] = proto;
+}