@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/Number.mts

@@ -0,0 +1,135 @@
+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 '../utils/language.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import {
+  IsIntegralNumber,
+  OrdinaryCreateFromConstructor,
+  ToNumeric,
+  F, R,
+  Realm,
+  type OrdinaryObject,
+} from '#self';
+
+export interface NumberObject extends OrdinaryObject {
+  readonly NumberData: NumberValue;
+}
+export function isNumberObject(o: Value): o is NumberObject {
+  return 'NumberData' in o;
+}
+
+/** 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,116 @@
+import {
+  ObjectValue,
+  Value,
+  NumberValue,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  Q, X, type ValueCompletion, type ValueEvaluator,
+} from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { NumberObject } from './Number.mts';
+import {
+  Assert,
+  SnapToInteger,
+  ToIntegerOrInfinity,
+  ToString,
+  F, R,
+  Realm,
+  Throw,
+  type Integer,
+} from '#self';
+
+export 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 Throw.TypeError('$1 is not a $2 object', value, 'Number');
+}
+
+/** 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, 10n);
+  }
+  if (f < 0 || f > 100) {
+    return Throw.RangeError('Invalid format range for $1', '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 Throw.RangeError('Invalid format range for $1', 'toFixed');
+  }
+  if (!x.isFinite()) {
+    return X(NumberValue.toString(x, 10n));
+  }
+  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, 10n));
+  }
+  if (p < 1 || p > 100) {
+    return Throw.RangeError('Invalid format range for $1', '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 radixMV: Integer;
+  if (radix === Value.undefined) {
+    radixMV = 10n;
+  } else {
+    radixMV = Q(yield* SnapToInteger(radix, 'truncate', 2n, 36n));
+  }
+  return NumberValue.toString(x, radixMV);
+}
+
+/** 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;
+}