@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/intrinsics/WeakSetPrototype.mts

@@ -0,0 +1,99 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  SameValue,
+  RequireInternalSlot,
+  CanBeHeldWeakly,
+  Realm,
+} from '../abstract-ops/all.mts';
+import {
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { Q, type ValueCompletion } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { WeakSetObject } from './WeakSet.mts';
+
+/** https://tc39.es/ecma262/#sec-weakset.prototype.add */
+function WeakSetProto_add([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let S be this value.
+  const S = thisValue as WeakSetObject;
+  // 2. Perform ? RequireInternalSlot(S, [[WeakSetData]]).
+  Q(RequireInternalSlot(S, 'WeakSetData'));
+  // 3. If CanBeHeldWeakly(value) is false, throw a TypeError exception.
+  if (CanBeHeldWeakly(value) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'WeakCollectionNotObject', value);
+  }
+  // 4. For each e that is an element of entries, do
+  const entries = S.WeakSetData;
+  for (const e of entries) {
+    // a. If e is not empty and SameValue(e, value) is true, then
+    if (e !== undefined && SameValue(e, value) === Value.true) {
+      // i. Return S.
+      return S;
+    }
+  }
+  // 6. Append value as the last element of entries.
+  entries.push(value);
+  // 6. Return S.
+  return S;
+}
+
+/** https://tc39.es/ecma262/#sec-weakset.prototype.delete */
+function WeakSetProto_delete([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let S be the this value.`
+  const S = thisValue as WeakSetObject;
+  // 2. Perform ? RequireInternalSlot(S, [[WeakSetData]]).
+  Q(RequireInternalSlot(S, 'WeakSetData'));
+  // 3. If CanBeHeldWeakly(value) is false, return false.
+  if (CanBeHeldWeakly(value) === Value.false) {
+    return Value.false;
+  }
+  // 4. For each element e of S.[[WeakSetData]], do
+  const entries = S.WeakSetData;
+  for (let i = 0; i < entries.length; i += 1) {
+    const e = entries[i];
+    // i. If e is not empty and SameValue(e, value) is true, then
+    if (e !== undefined && SameValue(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-weakset.prototype.has */
+function WeakSetProto_has([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let S be the this value.
+  const S = thisValue as WeakSetObject;
+  // 2. Perform ? RequireInternalSlot(S, [[WeakSetData]]).
+  Q(RequireInternalSlot(S, 'WeakSetData'));
+  // 3. If CanBeHeldWeakly(value) is false, return false.
+  if (CanBeHeldWeakly(value) === Value.false) {
+    return Value.false;
+  }
+  // 4. For each element e of S.[[WeakSetData]], do
+  const entries = S.WeakSetData;
+  for (const e of entries) {
+    // a. If e is not empty and SameValue(e, value) is true, return true.
+    if (e !== undefined && SameValue(e, value) === Value.true) {
+      return Value.true;
+    }
+  }
+  // 5. Return false.
+  return Value.false;
+}
+
+export function bootstrapWeakSetPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['add', WeakSetProto_add, 1],
+    ['delete', WeakSetProto_delete, 1],
+    ['has', WeakSetProto_has, 1],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'WeakSet');
+
+  realmRec.Intrinsics['%WeakSet.prototype%'] = proto;
+}

package/src/intrinsics/WrapForValidIteratorPrototype.mts

@@ -0,0 +1,66 @@
+import { __ts_cast__ } from '../helpers.mts';
+import {
+  type IteratorObject,
+} from '../abstract-ops/all.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import {
+  Assert,
+  Call,
+  CreateIteratorResultObject,
+  GetMethod,
+  ObjectValue,
+  Q,
+  RequireInternalSlot,
+  UndefinedValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+  type IteratorRecord,
+  type Realm,
+  type ValueEvaluator,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-%wrapforvaliditeratorprototype%.next */
+function* WrapForValidIteratorPrototype_next(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let O be this value.
+  const O = thisValue;
+  // 2. Perform ? RequireInternalSlot(O, [[Iterated]]).
+  Q(RequireInternalSlot(O, 'Iterated'));
+  // 3. Let iteratorRecord be O.[[Iterated]].
+  __ts_cast__<IteratorObject>(O);
+  const iteratorRecord: IteratorRecord = O.Iterated;
+  // 4. Return ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+  return Q(yield* Call(iteratorRecord.NextMethod, iteratorRecord.Iterator));
+}
+
+/** https://tc39.es/ecma262/#sec-%wrapforvaliditeratorprototype%.return */
+function* WrapForValidIteratorPrototype_return(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let O be this value.
+  const O = thisValue;
+  // 2. Perform ? RequireInternalSlot(O, [[Iterated]]).
+  Q(RequireInternalSlot(O, 'Iterated'));
+  // 3. Let iterator be O.[[Iterated]].[[Iterator]].
+  __ts_cast__<IteratorObject>(O);
+  const iteratorRecord: IteratorRecord = O.Iterated;
+  const iterator = iteratorRecord.Iterator;
+  // 4. Assert: iterator is an Object.
+  Assert(iterator instanceof ObjectValue);
+  // 5. Let returnMethod be ? GetMethod(iterator, "return").
+  const returnMethod = Q(yield* GetMethod(iterator, Value('return')));
+  // 6. If returnMethod is undefined, then
+  if (returnMethod instanceof UndefinedValue) {
+    // a. Return CreateIteratorResultObject(undefined, true).
+    return CreateIteratorResultObject(Value.undefined, Value.true);
+  }
+  // 7. Return ? Call(returnMethod, iterator).
+  return Q(yield* Call(returnMethod, iterator));
+}
+
+export function bootstrapWrapForValidIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', WrapForValidIteratorPrototype_next, 0],
+    ['return', WrapForValidIteratorPrototype_return, 0],
+  ], realmRec.Intrinsics['%Iterator.prototype%']);
+
+  realmRec.Intrinsics['%WrapForValidIteratorPrototype%'] = proto;
+}

package/src/intrinsics/bootstrap.mts

@@ -0,0 +1,152 @@
+import {
+  Assert,
+  CreateBuiltinFunction,
+  OrdinaryObjectCreate,
+  Realm,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  Descriptor,
+  JSStringValue,
+  NullValue,
+  ObjectValue,
+  SymbolValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type DescriptorInit,
+  type NativeSteps,
+} from '../value.mts';
+import { X } from '../completion.mts';
+
+type Accessor = [
+  getter: NativeSteps | UndefinedValue | FunctionObject,
+  setter?: NativeSteps | UndefinedValue | FunctionObject,
+];
+
+type Props = [
+  name: string | JSStringValue | SymbolValue,
+  value: Accessor | NativeSteps | Value,
+  fnLength?: number,
+  desc?: DescriptorInit
+];
+/** https://tc39.es/ecma262/#sec-ecmascript-standard-built-in-objects */
+export function assignProps(realmRec: Realm, obj: ObjectValue, props: readonly (Props | undefined)[]) {
+  for (const item of props) {
+    if (item === undefined) {
+      continue;
+    }
+    const [n, v, len, descriptor] = item;
+    const name = n instanceof Value ? n : Value(n);
+    if (Array.isArray(v)) {
+      // Every accessor property described in clauses 18 through 26 and in
+      // Annex B.2 has the attributes { [[Enumerable]]: false,
+      // [[Configurable]]: true } unless otherwise specified. If only a get
+      // accessor function is described, the set accessor function is the
+      // default value, undefined. If only a set accessor is described the get
+      // accessor is the default value, undefined.
+      let [
+        getter = Value.undefined,
+        setter = Value.undefined,
+      ] = v;
+      if (typeof getter === 'function') {
+        getter = CreateBuiltinFunction(
+          getter,
+          0,
+          name,
+          [],
+          realmRec,
+          undefined,
+          Value('get'),
+        );
+      }
+      if (typeof setter === 'function') {
+        setter = CreateBuiltinFunction(
+          setter,
+          1,
+          name,
+          [],
+          realmRec,
+          undefined,
+          Value('set'),
+        );
+      }
+      X(obj.DefineOwnProperty(name, Descriptor({
+        Get: getter,
+        Set: setter,
+        Enumerable: Value.false,
+        Configurable: Value.true,
+        ...descriptor,
+      })));
+    } else {
+      // Every other data property described in clauses 18 through 26 and in
+      // Annex B.2 has the attributes { [[Writable]]: true, [[Enumerable]]:
+      // false, [[Configurable]]: true } unless otherwise specified.
+      let value;
+      if (typeof v === 'function') {
+        Assert(typeof len === 'number');
+        value = CreateBuiltinFunction(v, len, name, [], realmRec);
+      } else {
+        value = v;
+      }
+      obj.properties.set(name, Descriptor({
+        Value: value,
+        Writable: Value.true,
+        Enumerable: Value.false,
+        Configurable: Value.true,
+        ...descriptor,
+      }));
+    }
+  }
+}
+
+export function bootstrapPrototype(realmRec: Realm, props: readonly (Props | undefined)[], Prototype: ObjectValue | NullValue, stringTag?: string) {
+  Assert(Prototype !== undefined);
+  const proto = OrdinaryObjectCreate(Prototype);
+
+  assignProps(realmRec, proto, props);
+
+  if (stringTag !== undefined) {
+    X(proto.DefineOwnProperty(wellKnownSymbols.toStringTag, Descriptor({
+      Value: Value(stringTag),
+      Writable: Value.false,
+      Enumerable: Value.false,
+      Configurable: Value.true,
+    })));
+  }
+
+  return proto;
+}
+
+export function bootstrapConstructor(realmRec: Realm, Constructor: NativeSteps, name: string, length: number, Prototype: ObjectValue, props: readonly Props[] = []) {
+  const cons = CreateBuiltinFunction(
+    Constructor,
+    length,
+    Value(name),
+    [],
+    realmRec,
+    undefined,
+    undefined,
+    Value.true,
+  );
+
+  X(cons.DefineOwnProperty(Value('prototype'), Descriptor({
+    Value: Prototype,
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+
+  if (!Prototype.properties.has('constructor')) {
+    X(Prototype.DefineOwnProperty(Value('constructor'), Descriptor({
+      Value: cons,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.true,
+    })));
+  }
+
+  assignProps(realmRec, cons, props);
+
+  return cons;
+}

package/src/intrinsics/eval.mts

@@ -0,0 +1,25 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import { Q, type ValueEvaluator } from '../completion.mts';
+import { Value, type Arguments } from '../value.mts';
+import {
+  Assert,
+  CreateBuiltinFunction,
+  PerformEval,
+  Realm,
+} from '../abstract-ops/all.mts';
+
+/** https://tc39.es/ecma262/#sec-eval-x */
+function* Eval([x = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Assert: The execution context stack has at least two elements.
+  Assert(surroundingAgent.executionContextStack.length >= 2);
+  // 2. Let callerContext be the second to top element of the execution context stack.
+  const callerContext = surroundingAgent.executionContextStack[surroundingAgent.executionContextStack.length - 2];
+  // 3. Let callerRealm be callerContext's Realm.
+  const callerRealm = callerContext.Realm;
+  // 4. Return ? PerformEval(x, callerRealm, false, false).
+  return Q(yield* PerformEval(x, callerRealm, false, false));
+}
+
+export function bootstrapEval(realmRec: Realm) {
+  realmRec.Intrinsics['%eval%'] = CreateBuiltinFunction(Eval, 1, Value('eval'), [], realmRec);
+}

package/src/intrinsics/isFinite.mts

@@ -0,0 +1,23 @@
+import {
+  ToNumber,
+  CreateBuiltinFunction,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { Value, type Arguments } from '../value.mts';
+import { Q, type ValueEvaluator } from '../completion.mts';
+
+/** https://tc39.es/ecma262/#sec-isfinite-number */
+function* IsFinite([number = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Let num be ? ToNumber(number).
+  const num = Q(yield* ToNumber(number));
+  // 2. If num is NaN, +∞, or -∞, return false.
+  if (num.isNaN() || num.isInfinity()) {
+    return Value.false;
+  }
+  // 3. Otherwise, return true.
+  return Value.true;
+}
+
+export function bootstrapIsFinite(realmRec: Realm) {
+  realmRec.Intrinsics['%isFinite%'] = CreateBuiltinFunction(IsFinite, 1, Value('isFinite'), [], realmRec);
+}

package/src/intrinsics/isNaN.mts

@@ -0,0 +1,23 @@
+import {
+  ToNumber,
+  CreateBuiltinFunction,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { Value, type Arguments } from '../value.mts';
+import { Q, type ValueEvaluator } from '../completion.mts';
+
+/** https://tc39.es/ecma262/#sec-isnan-number */
+function* IsNaN([number = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Let num be ? ToNumber(number).
+  const num = Q(yield* ToNumber(number));
+  // 2. If num is NaN, return true.
+  if (num.isNaN()) {
+    return Value.true;
+  }
+  // 3. Otherwise, return false.
+  return Value.false;
+}
+
+export function bootstrapIsNaN(realmRec: Realm) {
+  realmRec.Intrinsics['%isNaN%'] = CreateBuiltinFunction(IsNaN, 1, Value('isNaN'), [], realmRec);
+}

package/src/intrinsics/parseFloat.mts

@@ -0,0 +1,78 @@
+import {
+  CreateBuiltinFunction,
+  ToString,
+  F,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { Value, type Arguments } from '../value.mts';
+import {
+  TrimString,
+} from '../runtime-semantics/all.mts';
+
+/** https://tc39.es/ecma262/#sec-parsefloat-string */
+function* ParseFloat([string = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Let inputString be ? ToString(string).
+  const inputString = Q(yield* ToString(string));
+  // 2. Let trimmedString be ! TrimString(inputString, start).
+  const trimmedString = X(TrimString(inputString, 'start')).stringValue();
+  // 3. If neither trimmedString nor any prefix of trimmedString satisfies the syntax of a StrDecimalLiteral (see 7.1.4.1), return NaN.
+  // 4. Let numberString be the longest prefix of trimmedString, which might be trimmedString itself, that satisfies the syntax of a StrDecimalLiteral.
+  // 5. Let mathFloat be MV of numberString.
+  // 6. If mathFloat = 0ℝ, then
+  //   a. If the first code unit of trimmedString is the code unit 0x002D (HYPHEN-MINUS), return -0.
+  //   b. Return +0.
+  // 7. Return the Number value for mathFloat.
+  let numberString = trimmedString;
+  if (/^[+-]/.test(numberString)) {
+    numberString = numberString.slice(1);
+  }
+  const multiplier = trimmedString.startsWith('-') ? -1 : 1;
+  if (numberString.startsWith('Infinity')) {
+    return F(Infinity * multiplier);
+  }
+  let index = 0;
+  done: { // eslint-disable-line no-labels
+    // Eat leading zeros
+    while (numberString[index] === '0') {
+      index += 1;
+      if (index === numberString.length) {
+        return F(+0 * multiplier);
+      }
+    }
+    // Eat integer part
+    if (numberString[index] !== '.') {
+      while (/[0-9]/.test(numberString[index])) {
+        index += 1;
+      }
+    }
+    // Eat fractional part
+    if (numberString[index] === '.') {
+      if (!/[0-9eE]/.test(numberString[index + 1])) {
+        break done; // eslint-disable-line no-labels
+      }
+      index += 1;
+      while (/[0-9]/.test(numberString[index])) {
+        index += 1;
+      }
+    }
+    // Eat exponent part
+    if (numberString[index] === 'e' || numberString[index] === 'E') {
+      if (!/[-+0-9]/.test(numberString[index + 1])) {
+        break done; // eslint-disable-line no-labels
+      }
+      index += 1;
+      if (numberString[index] === '-' || numberString[index] === '+') {
+        index += 1;
+      }
+      while (/[0-9]/.test(numberString[index])) {
+        index += 1;
+      }
+    }
+  }
+  return F(parseFloat(numberString.slice(0, index)) * multiplier);
+}
+
+export function bootstrapParseFloat(realmRec: Realm) {
+  realmRec.Intrinsics['%parseFloat%'] = CreateBuiltinFunction(ParseFloat, 1, Value('parseFloat'), [], realmRec);
+}

package/src/intrinsics/parseInt.mts

@@ -0,0 +1,101 @@
+import {
+  Assert,
+  CreateBuiltinFunction,
+  ToInt32,
+  ToString,
+  F, R as MathematicalValue,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { TrimString } from '../runtime-semantics/all.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { Value, type Arguments } from '../value.mts';
+
+function digitToNumber(_digit: string) {
+  let digit = _digit.charCodeAt(0);
+  if (digit < 0x30 /* 0 */) {
+    return NaN;
+  }
+  if (digit <= 0x39 /* 9 */) {
+    return digit - 0x30;
+  }
+  // Convert to lower case.
+  digit &= ~0x20; // eslint-disable-line no-bitwise
+  if (digit < 0x41 /* A */) {
+    return NaN;
+  }
+  if (digit <= 0x5a /* Z */) {
+    return digit - 0x41 /* A */ + 10;
+  }
+  return NaN;
+}
+
+function stringToRadixNumber(str: string, R: number) {
+  let num = 0;
+  for (let i = 0; i < str.length; i += 1) {
+    const power = str.length - i - 1;
+    const multiplier = R ** power;
+    const dig = digitToNumber(str[i]);
+    Assert(!Number.isNaN(dig) && dig < R);
+    num += dig * multiplier;
+  }
+  return num;
+}
+
+function searchNotRadixDigit(str: string, R: number) {
+  for (let i = 0; i < str.length; i += 1) {
+    const num = digitToNumber(str[i]);
+    if (Number.isNaN(num) || num >= R) {
+      return i;
+    }
+  }
+  return str.length;
+}
+
+/** https://tc39.es/ecma262/#sec-parseint-string-radix */
+function* ParseInt([string = Value.undefined, radix = Value.undefined]: Arguments): ValueEvaluator {
+  const inputString = Q(yield* ToString(string));
+  let S = X(TrimString(inputString, 'start')).stringValue();
+  let sign = 1;
+  if (S !== '' && S[0] === '\x2D') {
+    sign = -1;
+  }
+  if (S !== '' && (S[0] === '\x2B' || S[0] === '\x2D')) {
+    S = S.slice(1);
+  }
+
+  let R = MathematicalValue(Q(yield* ToInt32(radix)));
+  let stripPrefix = true;
+  if (R !== 0) {
+    if (R < 2 || R > 36) {
+      return F(NaN);
+    }
+    if (R !== 16) {
+      stripPrefix = false;
+    }
+  } else {
+    R = 10;
+  }
+  if (stripPrefix === true) {
+    if (S.length >= 2 && (S.startsWith('0x') || S.startsWith('0X'))) {
+      S = S.slice(2);
+      R = 16;
+    }
+  }
+  const Z = S.slice(0, searchNotRadixDigit(S, R));
+  if (Z === '') {
+    return F(NaN);
+  }
+  const mathInt = stringToRadixNumber(Z, R);
+  if (mathInt === 0) {
+    if (sign === -1) {
+      return F(-0);
+    }
+    return F(+0);
+  }
+  const number = mathInt;
+  return F(sign * number);
+}
+
+export function bootstrapParseInt(realmRec: Realm) {
+  realmRec.Intrinsics['%parseInt%'] = CreateBuiltinFunction(ParseInt, 2, Value('parseInt'), [], realmRec);
+}