@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/intrinsics/Math.mts

@@ -0,0 +1,288 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Descriptor,
+  Value,
+  NumberValue,
+  type Arguments,
+} from '../value.mts';
+import {
+  CreateBuiltinFunction,
+  ToNumber,
+  F, R,
+  Realm,
+  RequireObjectCoercible,
+  GetIterator,
+  IteratorStepValue,
+  IteratorClose,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-math.abs */
+function* Math_abs([x = Value.undefined]: Arguments): ValueEvaluator {
+  const n = Q(yield* ToNumber(x));
+  if (n.isNaN()) {
+    return n;
+  } else if (Object.is(R(n), -0)) {
+    return F(+0);
+  } else if (n.isInfinity()) {
+    return F(Infinity);
+  }
+
+  if (R(n) < 0) {
+    return F(-R(n));
+  }
+  return n;
+}
+
+/** https://tc39.es/ecma262/#sec-math.acos */
+function* Math_acos([x = Value.undefined]: Arguments): ValueEvaluator {
+  const n = Q(yield* ToNumber(x));
+  if (n.isNaN()) {
+    return n;
+  } else if (R(n) > 1) {
+    return F(NaN);
+  } else if (R(n) < -1) {
+    return F(NaN);
+  } else if (R(n) === 1) {
+    return F(+0);
+  }
+
+  return F(Math.acos(R(n)));
+}
+
+/** https://tc39.es/ecma262/#sec-math.pow */
+function* Math_pow([base = Value.undefined, exponent = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Set base to ? ToNumber(base).
+  base = Q(yield* ToNumber(base));
+  // 2. Set exponent to ? ToNumber(exponent).
+  exponent = Q(yield* ToNumber(exponent));
+  // 3. Return ! Number::exponentiate(base, exponent).
+  return X(NumberValue.exponentiate(base, exponent));
+}
+
+/** @param {bigint} h */
+function fmix64(h: bigint) {
+  h ^= h >> 33n;
+  h *= 0xFF51AFD7ED558CCDn;
+  h ^= h >> 33n;
+  h *= 0xC4CEB9FE1A85EC53n;
+  h ^= h >> 33n;
+  return h;
+}
+
+const floatView = new Float64Array(1);
+const big64View = new BigUint64Array(floatView.buffer);
+/** https://tc39.es/ecma262/#sec-math.random */
+function Math_random() {
+  const realm = surroundingAgent.currentRealmRecord;
+  if (realm.randomState === undefined) {
+    const seed = realm.HostDefined.randomSeed
+      ? BigInt(X(realm.HostDefined.randomSeed()))
+      : BigInt(Math.round(Math.random() * (2 ** 32)));
+    realm.randomState = new BigUint64Array([
+      fmix64(BigInt.asUintN(64, seed)),
+      fmix64(BigInt.asUintN(64, ~seed)),
+    ]);
+  }
+  const s = realm.randomState;
+
+  // XorShift128+
+  let s1 = s[0];
+  const s0 = s[1];
+  s[0] = s0;
+  s1 ^= s1 << 23n;
+  s1 ^= s1 >> 17n;
+  s1 ^= s0;
+  s1 ^= s0 >> 26n;
+  s[1] = s1;
+
+  // Convert to double in [0, 1) range
+  big64View[0] = (s0 >> 12n) | 0x3FF0000000000000n;
+  const result = floatView[0] - 1;
+  return F(result);
+}
+
+/** https://tc39.es/ecma262/#sec-math.sumprecise */
+function* Math_sumPrecise([items = Value.undefined]: Arguments): ValueEvaluator {
+  Q(RequireObjectCoercible(items));
+  const iteratorRecord = Q(yield* GetIterator(items, 'sync'));
+  let state: 'minus-zero' | 'not-a-number' | 'minus-infinity' | 'plus-infinity' | 'finite' = 'minus-zero';
+  const sums: number[] = [];
+  let count = 0;
+  let next: 'not-started' | 'done' | Value = 'not-started';
+  while (next !== 'done') {
+    next = Q(yield* IteratorStepValue(iteratorRecord));
+    if (next !== 'done') {
+      if (count >= 2 ** 53 - 1) {
+        const error = surroundingAgent.Throw('RangeError', 'OutOfRange', '');
+        return Q(yield* IteratorClose(iteratorRecord, error));
+      }
+      if (!(next instanceof NumberValue)) {
+        const error = surroundingAgent.Throw('TypeError', 'NotANumber', next);
+        return Q(yield* IteratorClose(iteratorRecord, error));
+      }
+      const n = R(next);
+      if (state !== 'not-a-number') {
+        if (Number.isNaN(n)) {
+          state = 'not-a-number';
+        } else if (n === Infinity) {
+          if (state === 'minus-infinity') {
+            state = 'not-a-number';
+          } else {
+            state = 'plus-infinity';
+          }
+        } else if (n === -Infinity) {
+          if (state === 'plus-infinity') {
+            state = 'not-a-number';
+          } else {
+            state = 'minus-infinity';
+          }
+        } else if (!Object.is(n, -0) && (state === 'minus-zero' || state === 'finite')) {
+          state = 'finite';
+          sums.push(n);
+        }
+      }
+      count += 1;
+    }
+  }
+  if (state === 'not-a-number') {
+    return F(NaN);
+  }
+  if (state === 'plus-infinity') {
+    return F(Infinity);
+  }
+  if (state === 'minus-infinity') {
+    return F(-Infinity);
+  }
+  if (state === 'minus-zero') {
+    return F(-0);
+  }
+  return F(sum(sums));
+
+  function sum(items: number[]) {
+    if ('sumPrecise' in Math) {
+      // @ts-expect-error
+      return Math.sumPrecise(items);
+    }
+    const fractional_parts: number[] = [];
+    let whole_part_sum = 0n;
+    items.forEach((n) => {
+      const whole_num = Math.trunc(n);
+      fractional_parts.push(n - whole_num);
+      whole_part_sum += BigInt(whole_num);
+    });
+    const fractional_parts_as_hex = fractional_parts.map((n) => n.toString(32));
+
+    const fractional: number[] = [];
+    for (const fractional_str of fractional_parts_as_hex) {
+      const neg = fractional_str[0] === '-';
+      const prefix = neg ? 3 : 2; // -0.xxx or 0.xxx
+      for (let index = prefix; index < fractional_str.length; index += 1) {
+        fractional[index - prefix] ??= 0;
+        if (neg) {
+          fractional[index - prefix] -= parseInt(fractional_str[index], 32);
+        } else {
+          fractional[index - prefix] += parseInt(fractional_str[index], 32);
+        }
+      }
+    }
+    for (let index = fractional.length - 1; index >= 0; index -= 1) {
+      const element = fractional[index];
+      if (element >= 32) {
+        fractional[index] = element % 32;
+        fractional[index - 1] ??= 0;
+        fractional[index - 1] += Math.floor(element / 32);
+      }
+      if (element < 0) {
+        fractional[index] = 32 + element;
+        fractional[index - 1] ??= 0;
+        fractional[index - 1] -= 1;
+      }
+    }
+    const fractional_part = fractional.reduceRight((acc, digit, index) => acc + digit * 32 ** -(index + 1), 0);
+    if (fractional[-1]) {
+      whole_part_sum += BigInt(fractional[-1]);
+    }
+    return Number(whole_part_sum) + fractional_part;
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-math-object */
+export function bootstrapMath(realmRec: Realm) {
+  /** https://tc39.es/ecma262/#sec-value-properties-of-the-math-object */
+  const readonly = { Writable: Value.false, Configurable: Value.false };
+
+  // @@toStringTag is handled in the bootstrapPrototype() call.
+  const mathObj = bootstrapPrototype(realmRec, [
+    ['E', F(2.718281828459045), undefined, readonly],
+    ['LN10', F(2.302585092994046), undefined, readonly],
+    ['LN2', F(0.6931471805599453), undefined, readonly],
+    ['LOG10E', F(0.4342944819032518), undefined, readonly],
+    ['LOG2E', F(1.4426950408889634), undefined, readonly],
+    ['PI', F(3.141592653589793), undefined, readonly],
+    ['SQRT1_2', F(0.7071067811865476), undefined, readonly],
+    ['SQRT2', F(1.4142135623730951), undefined, readonly],
+    ['abs', Math_abs, 1],
+    ['acos', Math_acos, 1],
+    ['pow', Math_pow, 2],
+    ['random', Math_random, 0],
+    ['sumPrecise', Math_sumPrecise, 1],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Math');
+
+  /** https://tc39.es/ecma262/#sec-function-properties-of-the-math-object */
+
+  ([
+    ['acosh', 1],
+    ['asin', 1],
+    ['asinh', 1],
+    ['atan', 1],
+    ['atanh', 1],
+    ['atan2', 2],
+    ['cbrt', 1],
+    ['ceil', 1],
+    ['clz32', 1],
+    ['cos', 1],
+    ['cosh', 1],
+    ['exp', 1],
+    ['expm1', 1],
+    ['floor', 1],
+    ['fround', 1],
+    ['hypot', 2],
+    ['imul', 2],
+    ['log', 1],
+    ['log1p', 1],
+    ['log10', 1],
+    ['log2', 1],
+    ['max', 2],
+    ['min', 2],
+    ['round', 1],
+    ['sign', 1],
+    ['sin', 1],
+    ['sinh', 1],
+    ['sqrt', 1],
+    ['tan', 1],
+    ['tanh', 1],
+    ['trunc', 1],
+  ] as const).forEach(([name, length]) => {
+    // TODO(18): Math
+    /** https://tc39.es/ecma262/#sec-function-properties-of-the-math-object */
+    const method = function* method(args: Arguments): ValueEvaluator {
+      const nextArgs: number[] = [];
+      for (let i = 0; i < args.length; i += 1) {
+        nextArgs[i] = R(Q(yield* ToNumber(args[i])));
+      }
+      // we're calling host Math functions here.
+      return F((Math[name] as (...args: unknown[]) => number)(...nextArgs));
+    };
+    const func = CreateBuiltinFunction(method, length, Value(name), [], realmRec);
+    X(mathObj.DefineOwnProperty(Value(name), Descriptor({
+      Value: func,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.true,
+    })));
+  });
+
+  realmRec.Intrinsics['%Math%'] = mathObj;
+}

package/src/intrinsics/NativeError.mts

@@ -0,0 +1,88 @@
+import {
+  surroundingAgent,
+} from '../host-defined/engine.mts';
+import {
+  DefinePropertyOrThrow,
+  OrdinaryCreateFromConstructor,
+  InstallErrorCause,
+  ToString,
+  Realm,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  Descriptor,
+  UndefinedValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { captureStack, errorStackToString } from '../helpers.mts';
+import { bootstrapConstructor, bootstrapPrototype } from './bootstrap.mts';
+import type { ErrorObject } from './Error.mts';
+
+const nativeErrorNames = [
+  'EvalError',
+  'RangeError',
+  'ReferenceError',
+  'SyntaxError',
+  'TypeError',
+  'URIError',
+] as const;
+export type NativeErrorNames = typeof nativeErrorNames[number];
+export function bootstrapNativeError(realmRec: Realm) {
+  for (const name of nativeErrorNames) {
+    const proto = bootstrapPrototype(realmRec, [
+      ['name', Value(name)],
+      ['message', Value('')],
+    ], realmRec.Intrinsics['%Error.prototype%']);
+
+    /** https://tc39.es/ecma262/#sec-nativeerror */
+    const Constructor = function* Constructor([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 instanceof UndefinedValue) {
+        newTarget = surroundingAgent.activeFunctionObject;
+      } else {
+        newTarget = NewTarget;
+      }
+      // 2. Let O be ? OrdinaryCreateFromConstructor(newTarget, "%NativeError.prototype%", « [[ErrorData]] »).
+      const O = Q(yield* OrdinaryCreateFromConstructor(newTarget as FunctionObject, `%${name}.prototype%`, [
+        'ErrorData',
+        'HostDefinedErrorStack',
+      ])) 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));
+      // NON-SPEC
+      const S = captureStack();
+      O.HostDefinedErrorStack = S.stack;
+      O.ErrorData = X(errorStackToString(O, S.stack, S.nativeStack));
+      // 5. Return O.
+      return O;
+    };
+    Object.defineProperty(Constructor, 'name', {
+      value: `${name}Constructor`,
+      configurable: true,
+    });
+
+    const cons = bootstrapConstructor(realmRec, Constructor, name, 1, proto, []);
+    cons.Prototype = realmRec.Intrinsics['%Error%'];
+
+    realmRec.Intrinsics[`%${name}.prototype%`] = proto;
+    realmRec.Intrinsics[`%${name}%`] = cons;
+  }
+}

package/src/intrinsics/Number.mts

@@ -0,0 +1,131 @@
+import {
+  IsIntegralNumber,
+  OrdinaryCreateFromConstructor,
+  ToNumeric,
+  F, R,
+  Realm,
+  type OrdinaryObject,
+} from '../abstract-ops/all.mts';
+import {
+  Descriptor,
+  NumberValue,
+  BigIntValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+  UndefinedValue,
+} from '../value.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+export interface NumberObject extends OrdinaryObject {
+  readonly NumberData: NumberValue;
+}
+/** https://tc39.es/ecma262/#sec-number-constructor-number-value */
+function* NumberConstructor([value]: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  let n;
+  if (value !== undefined) {
+    const prim = Q(yield* ToNumeric(value));
+    if (prim instanceof BigIntValue) {
+      n = F(Number(R(prim)));
+    } else {
+      n = prim;
+    }
+  } else {
+    n = F(+0);
+  }
+  if (NewTarget instanceof UndefinedValue) {
+    return n;
+  }
+  const O = (yield* OrdinaryCreateFromConstructor(NewTarget, '%Number.prototype%', ['NumberData'])) as Mutable<NumberObject>;
+  O.NumberData = n;
+  return O;
+}
+
+/** https://tc39.es/ecma262/#sec-number.isfinite */
+function Number_isFinite([number = Value.undefined]: Arguments) {
+  if (!(number instanceof NumberValue)) {
+    return Value.false;
+  }
+
+  if (number.isNaN() || number.isInfinity()) {
+    return Value.false;
+  }
+  return Value.true;
+}
+
+/** https://tc39.es/ecma262/#sec-number.isinteger */
+function Number_isInteger([number = Value.undefined]: Arguments) {
+  return X(IsIntegralNumber(number));
+}
+
+/** https://tc39.es/ecma262/#sec-number.isnan */
+function Number_isNaN([number = Value.undefined]: Arguments) {
+  if (!(number instanceof NumberValue)) {
+    return Value.false;
+  }
+
+  if (number.isNaN()) {
+    return Value.true;
+  }
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-number.issafeinteger */
+function Number_isSafeInteger([number = Value.undefined]: Arguments) {
+  if (!(number instanceof NumberValue)) {
+    return Value.false;
+  }
+
+  if (X(IsIntegralNumber(number)) === Value.true) {
+    if (Math.abs(R(number)) <= (2 ** 53) - 1) {
+      return Value.true;
+    }
+  }
+
+  return Value.false;
+}
+
+export function bootstrapNumber(realmRec: Realm) {
+  const override = {
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  };
+  const numberConstructor = bootstrapConstructor(realmRec, NumberConstructor, 'Number', 1, realmRec.Intrinsics['%Number.prototype%'], [
+    ['EPSILON', F(Number.EPSILON), undefined, override],
+    ['MAX_SAFE_INTEGER', F(Number.MAX_SAFE_INTEGER), undefined, override],
+    ['MAX_VALUE', F(Number.MAX_VALUE), undefined, override],
+    ['MIN_SAFE_INTEGER', F(Number.MIN_SAFE_INTEGER), undefined, override],
+    ['MIN_VALUE', F(Number.MIN_VALUE), undefined, override],
+    ['NaN', F(NaN), undefined, override],
+    ['NEGATIVE_INFINITY', F(-Infinity), undefined, override],
+    ['POSITIVE_INFINITY', F(+Infinity), undefined, override],
+
+    ['isFinite', Number_isFinite, 1],
+    ['isInteger', Number_isInteger, 1],
+    ['isNaN', Number_isNaN, 1],
+    ['isSafeInteger', Number_isSafeInteger, 1],
+  ]);
+
+  /** https://tc39.es/ecma262/#sec-number.parsefloat */
+  // The value of the Number.parseFloat data property is the same built-in function object that is the value of the parseFloat property of the global object defined in 18.2.4.
+  X(numberConstructor.DefineOwnProperty(Value('parseFloat'), Descriptor({
+    Value: realmRec.Intrinsics['%parseFloat%'],
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+
+  /** https://tc39.es/ecma262/#sec-number.parseint */
+  // The value of the Number.parseInt data property is the same built-in function object that is the value of the parseInt property of the global object defined in 18.2.5.
+  X(numberConstructor.DefineOwnProperty(Value('parseInt'), Descriptor({
+    Value: realmRec.Intrinsics['%parseInt%'],
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+
+  realmRec.Intrinsics['%Number%'] = numberConstructor;
+}

package/src/intrinsics/NumberPrototype.mts

@@ -0,0 +1,125 @@
+import {
+  ObjectValue,
+  Value,
+  NumberValue,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  Assert,
+  ToIntegerOrInfinity,
+  ToString,
+  F, R,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Q, X, type ValueCompletion, type ValueEvaluator,
+} from '../completion.mts';
+import type { Mutable } from '../helpers.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { NumberObject } from './Number.mts';
+
+function thisNumberValue(value: Value) {
+  if (value instanceof NumberValue) {
+    return value;
+  }
+  if (value instanceof ObjectValue && 'NumberData' in value) {
+    const n = value.NumberData;
+    Assert(n instanceof NumberValue);
+    return n;
+  }
+  return surroundingAgent.Throw('TypeError', 'NotATypeObject', 'Number', value);
+}
+
+/** https://tc39.es/ecma262/#sec-number.prototype.toexponential */
+function* NumberProto_toExponential([fractionDigits = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const x = Q(thisNumberValue(thisValue));
+  const f = Q(yield* ToIntegerOrInfinity(fractionDigits));
+  Assert(fractionDigits !== Value.undefined || f === 0);
+  if (!x.isFinite()) {
+    return NumberValue.toString(x, 10);
+  }
+  if (f < 0 || f > 100) {
+    return surroundingAgent.Throw('RangeError', 'NumberFormatRange', 'toExponential');
+  }
+  return Value(R(x).toExponential(fractionDigits === Value.undefined ? undefined : f));
+}
+
+/** https://tc39.es/ecma262/#sec-number.prototype.tofixed */
+function* NumberProto_toFixed([fractionDigits = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const x = Q(thisNumberValue(thisValue));
+  const f = Q(yield* ToIntegerOrInfinity(fractionDigits));
+  Assert(fractionDigits !== Value.undefined || f === 0);
+  if (f < 0 || f > 100) {
+    return surroundingAgent.Throw('RangeError', 'NumberFormatRange', 'toFixed');
+  }
+  if (!x.isFinite()) {
+    return X(NumberValue.toString(x, 10));
+  }
+  return Value(R(x).toFixed(f));
+}
+
+/** https://tc39.es/ecma262/#sec-number.prototype.tolocalestring */
+function NumberProto_toLocaleString(_args: Arguments, context: FunctionCallContext): ValueEvaluator {
+  return NumberProto_toString([], context);
+}
+
+/** https://tc39.es/ecma262/#sec-number.prototype.toprecision */
+function* NumberProto_toPrecision([precision = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const x = Q(thisNumberValue(thisValue));
+  if (precision === Value.undefined) {
+    return X(ToString(x));
+  }
+  const p = Q(yield* ToIntegerOrInfinity(precision));
+  if (!x.isFinite()) {
+    return X(NumberValue.toString(x, 10));
+  }
+  if (p < 1 || p > 100) {
+    return surroundingAgent.Throw('RangeError', 'NumberFormatRange', 'toPrecision');
+  }
+  return Value(R(x).toPrecision(p));
+}
+
+/** https://tc39.es/ecma262/#sec-number.prototype.tostring */
+function* NumberProto_toString([radix = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const x = Q(thisNumberValue(thisValue));
+  let radixNumber;
+  if (radix === Value.undefined) {
+    radixNumber = 10;
+  } else {
+    radixNumber = Q(yield* ToIntegerOrInfinity(radix));
+  }
+  if (radixNumber < 2 || radixNumber > 36) {
+    return surroundingAgent.Throw('RangeError', 'NumberFormatRange', 'toString');
+  }
+  if (radixNumber === 10) {
+    return X(ToString(x));
+  }
+  // FIXME(devsnek): Return the String representation of this Number
+  // value using the radix specified by radixNumber. Letters a-z are
+  // used for digits with values 10 through 35. The precise algorithm
+  // is implementation-dependent, however the algorithm should be a
+  // generalization of that specified in 7.1.12.1.
+  return Value(R(x).toString(radixNumber));
+}
+
+/** https://tc39.es/ecma262/#sec-number.prototype.valueof */
+function NumberProto_valueOf(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  return Q(thisNumberValue(thisValue));
+}
+
+export function bootstrapNumberPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['toExponential', NumberProto_toExponential, 1],
+    ['toFixed', NumberProto_toFixed, 1],
+    ['toLocaleString', NumberProto_toLocaleString, 0],
+    ['toPrecision', NumberProto_toPrecision, 1],
+    ['toString', NumberProto_toString, 1],
+    ['valueOf', NumberProto_valueOf, 0],
+  ], realmRec.Intrinsics['%Object.prototype%']);
+
+  (proto as Mutable<NumberObject>).NumberData = F(+0);
+
+  realmRec.Intrinsics['%Number.prototype%'] = proto;
+}