@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/intrinsics/RegExpStringIteratorPrototype.mts

@@ -0,0 +1,73 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  JSStringValue, NullValue, ObjectValue, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import {
+  CreateIteratorFromClosure,
+  GeneratorResume,
+  ToString,
+  ToLength,
+  Get,
+  Set,
+  Yield,
+  F, R as MathematicalValue,
+  Realm,
+  type GeneratorObject,
+} from '../abstract-ops/all.mts';
+import {
+  Q, X, type ValueCompletion, type ValueEvaluator,
+} from '../completion.mts';
+import { RegExpExec, AdvanceStringIndex } from './RegExpPrototype.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-createregexpstringiterator */
+export function CreateRegExpStringIterator(R: ObjectValue, S: JSStringValue, global: boolean, fullUnicode: boolean): ValueCompletion<GeneratorObject> {
+  // 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(): ValueEvaluator {
+    // a. Repeat,
+    while (true) {
+      // i. Let match be ? RegExpExec(R, S).
+      const match = Q(yield* 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) {
+        // 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(yield* ToString(Q(yield* 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(yield* ToLength(Q(yield* 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(yield* 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, Value('%RegExpStringIteratorPrototype%'), surroundingAgent.intrinsic('%RegExpStringIteratorPrototype%')));
+}
+
+/** https://tc39.es/ecma262/#sec-%regexpstringiteratorprototype%.next */
+function* RegExpStringIteratorPrototype_next(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Return ? GeneratorResume(this value, empty, "%RegExpStringIteratorPrototype%").
+  return Q(yield* GeneratorResume(thisValue, undefined, Value('%RegExpStringIteratorPrototype%')));
+}
+
+export function bootstrapRegExpStringIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', RegExpStringIteratorPrototype_next, 0],
+  ], realmRec.Intrinsics['%Iterator.prototype%'], 'RegExp String Iterator');
+
+  realmRec.Intrinsics['%RegExpStringIteratorPrototype%'] = proto;
+}

package/src/intrinsics/Set.mts

@@ -0,0 +1,75 @@
+import { surroundingAgent } from '../host-defined/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)[];
+}
+export function isSetObject(value: Value): value is SetObject {
+  return 'SetData' in value;
+}
+/** 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(yield* 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(yield* Get(set, Value('add')));
+  // 6. If IsCallable(adder) is false, throw a TypeError exception.
+  if (!IsCallable(adder)) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', adder);
+  }
+  // 7. Let iteratorRecord be ? GetIterator(iterable).
+  const iteratorRecord = Q(yield* GetIterator(iterable, 'sync'));
+  // 8. Repeat,
+  while (true) {
+    // a. Let next be ? IteratorStepValue(iteratorRecord).
+    const next = Q(yield* IteratorStepValue(iteratorRecord));
+    // b. If next is false, return set.
+    if (next === 'done') {
+      return set;
+    }
+    // d. Let status be Call(adder, set, « next »).
+    const status = yield* 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,78 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Assert,
+  CreateArrayFromList,
+  CreateIteratorFromClosure,
+  GeneratorResume,
+  Realm,
+  RequireInternalSlot,
+  Yield,
+  type GeneratorObject,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ValueCompletion } from '../completion.mts';
+import {
+  Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import type { ValueEvaluator, YieldEvaluator } from '../evaluator.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { SetObject } from './Set.mts';
+
+/** https://tc39.es/ecma262/#sec-createsetiterator */
+export function CreateSetIterator(set: Value, kind: 'key+value' | 'value'): ValueCompletion<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;
+    }
+    // NON-SPEC
+    generator.HostCapturedValues = undefined;
+    // e. Return undefined.
+    return Value.undefined;
+  };
+  // 4. Return ! CreateIteratorFromClosure(closure, "%SetIteratorPrototype%", %SetIteratorPrototype%).
+  const generator = X(CreateIteratorFromClosure(closure, Value('%SetIteratorPrototype%'), surroundingAgent.intrinsic('%SetIteratorPrototype%'), ['HostCapturedValues'], [set]));
+  return generator;
+}
+
+/** https://tc39.es/ecma262/#sec-%setiteratorprototype%.next */
+function* SetIteratorPrototype_next(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Return ? GeneratorResume(this value, empty, "%SetIteratorPrototype%").
+  return Q(yield* GeneratorResume(thisValue, undefined, Value('%SetIteratorPrototype%')));
+}
+
+export function bootstrapSetIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', SetIteratorPrototype_next, 0],
+  ], realmRec.Intrinsics['%Iterator.prototype%'], 'Set Iterator');
+
+  realmRec.Intrinsics['%SetIteratorPrototype%'] = proto;
+}