@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/intrinsics/MapIteratorPrototype.mts

@@ -0,0 +1,79 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Assert,
+  CreateArrayFromList,
+  CreateIteratorFromClosure,
+  GeneratorResume,
+  Realm,
+  RequireInternalSlot,
+  Yield,
+} from '../abstract-ops/all.mts';
+import { Q, X } from '../completion.mts';
+import { Value, type Arguments } from '../value.mts';
+import type { YieldEvaluator } from '../evaluator.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type {
+  ExpressionCompletion, FunctionCallContext, GeneratorObject, MapObject,
+} from '#self';
+
+const kMapIteratorPrototype = Value('%MapIteratorPrototype%');
+
+/** https://tc39.es/ecma262/#sec-createmapiterator */
+export function CreateMapIterator(map: Value, kind: 'key+value' | 'key' | 'value'): ExpressionCompletion<GeneratorObject> {
+  Assert(kind === 'key+value' || kind === 'key' || kind === 'value');
+  // 1. Perform ? RequireInternalSlot(map, [[MapData]]).
+  Q(RequireInternalSlot(map, 'MapData'));
+  // 2. Let closure be a new Abstract Closure with no parameters that captures map and kind and performs the following steps when called:
+  const closure = function* closure(): YieldEvaluator {
+    // a. Let entries be the List that is map.[[MapData]].
+    const entries = (map as MapObject).MapData;
+    // b. Let index be 0.
+    let index = 0;
+    // 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 the Record { [[Key]], [[Value]] } that is the value of entries[index].
+      const e = entries[index];
+      // ii. Set index to index + 1.
+      index += 1;
+      // iii. If e.[[Key]] is not empty, then
+      if (e.Key !== undefined) {
+        let result;
+        // 1. If kind is key, let result be e.[[Key]].
+        if (kind === 'key') {
+          result = e.Key;
+        } else if (kind === 'value') { // 2. Else if kind is value, let result be e.[[Value]].
+          result = e.Value;
+        } else { // 3. Else,
+          // a. Assert: kind is key+value.
+          Assert(kind === 'key+value');
+          // b. Let result be ! CreateArrayFromList(« e.[[Key]], e.[[Value]] »).
+          result = X(CreateArrayFromList([e.Key, e.Value!]));
+        }
+        // 4. Perform ? Yield(result).
+        Q(yield* Yield(result!));
+      }
+      // iv. Set numEntries to the number of elements of entries.
+      numEntries = entries.length;
+    }
+    // e. Return undefined.
+    return Value.undefined;
+  };
+  // 3. Return ! CreateIteratorFromClosure(closure, "%MapIteratorPrototype%", %MapIteratorPrototype%).
+  return X(CreateIteratorFromClosure(closure, kMapIteratorPrototype, surroundingAgent.intrinsic('%MapIteratorPrototype%')));
+}
+
+/** https://tc39.es/ecma262/#sec-%mapiteratorprototype%.next */
+function MapIteratorPrototype_next(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Return ? GeneratorResume(this value, empty, "%MapIteratorPrototype%")
+  return Q(GeneratorResume(thisValue, undefined, kMapIteratorPrototype));
+}
+
+export function bootstrapMapIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', MapIteratorPrototype_next, 0],
+  ], realmRec.Intrinsics['%IteratorPrototype%'], 'Map Iterator');
+
+  realmRec.Intrinsics['%MapIteratorPrototype%'] = proto;
+}

package/src/intrinsics/MapPrototype.mts

@@ -0,0 +1,226 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Call,
+  F,
+  IsCallable,
+  RequireInternalSlot,
+  SameValueZero, R,
+} from '../abstract-ops/all.mts';
+import {
+  NumberValue,
+  Value,
+  wellKnownSymbols,
+} from '../value.mts';
+import { Q, X } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import { CreateMapIterator } from './MapIteratorPrototype.mts';
+import type { MapObject } from './Map.mts';
+import type {
+  Arguments, Descriptor, ExpressionCompletion, FunctionCallContext, Realm,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-map.prototype.clear */
+function MapProto_clear(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  if (entries.length) {
+    Q(surroundingAgent.debugger_tryTouchDuringPreview(M));
+  }
+  for (const p of entries) {
+    // a. Set p.[[Key]] to empty.
+    p.Key = undefined;
+    // b. Set p.[[Value]] to empty.
+    p.Value = undefined;
+  }
+  // 5. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.delete */
+function MapProto_delete([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entires be M.[[MapData]].
+  const entries = M.MapData;
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, then
+    if (p.Key !== undefined && SameValueZero(p.Key, key) === Value.true) {
+      Q(surroundingAgent.debugger_tryTouchDuringPreview(M));
+      // i. Set p.[[Key]] to empty.
+      p.Key = undefined;
+      // ii. Set p.[[Value]] to empty.
+      p.Value = undefined;
+      // iii. Return true.
+      return Value.true;
+    }
+  }
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.entries */
+function MapProto_entries(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue;
+  // 2. Return ? CreateMapIterator(M, key+value);
+  return Q(CreateMapIterator(M, 'key+value'));
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.foreach */
+function MapProto_forEach([callbackfn = Value.undefined, thisArg = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 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 M.[[MapData]].
+  const entries = M.MapData;
+  // 5. For each Record { [[Key]], [[Value]] } e that is an element of entries, in original key insertion order, do
+  for (const e of entries) {
+    // a. If e.[[Key]] is not empty, then
+    if (e.Key !== undefined) {
+      // i. Perform ? Call(callbackfn, thisArg, « e.[[Value]], e.[[Key]], M »).
+      Q(Call(callbackfn, thisArg, [e.Value!, e.Key, M]));
+    }
+  }
+  // 6. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.get */
+function MapProto_get([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, return p.[[Value]].
+    if (p.Key !== undefined && SameValueZero(p.Key, key) === Value.true) {
+      // i. Return p.[[Value]].
+      return p.Value!;
+    }
+  }
+  // 5. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.has */
+function MapProto_has([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, return true.
+    if (p.Key !== undefined && SameValueZero(p.Key, key) === Value.true) {
+      return Value.true;
+    }
+  }
+  // 5. Return false.
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.keys */
+function MapProto_keys(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue;
+  // 2. Return ? CreateMapIterator(M, key).
+  return Q(CreateMapIterator(M, 'key'));
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.set */
+function MapProto_set([key = Value.undefined, value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, then
+    if (p.Key !== undefined && SameValueZero(p.Key, key) === Value.true) {
+      // i. Set p.[[Value]] to value.
+      Q(surroundingAgent.debugger_tryTouchDuringPreview(M));
+      p.Value = value;
+      // ii. Return M.
+      return M;
+    }
+  }
+  // 5. If key is -0𝔽, set key to +0𝔽.
+  if (key instanceof NumberValue && Object.is(R(key), -0)) {
+    key = F(+0);
+  }
+  // 6. Let p be the Record { [[Key]]: key, [[Value]]: value }.
+  const p = { Key: key, Value: value };
+  // 7. Append p as the last element of entries.
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(M));
+  entries.push(p);
+  // 8. Return M.
+  return M;
+}
+
+/** https://tc39.es/ecma262/#sec-get-map.prototype.size */
+function MapProto_sizeGetter(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 4. Let count be 0.
+  let count = 0;
+  // 5. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty, set count to count + 1.
+    if (p.Key !== undefined) {
+      count += 1;
+    }
+  }
+  // 6. Return 𝔽(count).
+  return F(count);
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.values */
+function MapProto_values(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue;
+  // 2. Return ? CreateMapIterator(M, value).
+  return Q(CreateMapIterator(M, 'value'));
+}
+
+export function bootstrapMapPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['clear', MapProto_clear, 0],
+    ['delete', MapProto_delete, 1],
+    ['entries', MapProto_entries, 0],
+    ['forEach', MapProto_forEach, 1],
+    ['get', MapProto_get, 1],
+    ['has', MapProto_has, 1],
+    ['keys', MapProto_keys, 0],
+    ['set', MapProto_set, 2],
+    ['size', [MapProto_sizeGetter]],
+    ['values', MapProto_values, 0],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Map');
+
+  const entriesFunc = X(proto.GetOwnProperty(Value('entries')));
+  X(proto.DefineOwnProperty(wellKnownSymbols.iterator, entriesFunc as Descriptor));
+
+  realmRec.Intrinsics['%Map.prototype%'] = proto;
+}

package/src/intrinsics/Math.mts

@@ -0,0 +1,178 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Descriptor,
+  Value,
+  NumberValue,
+  type Arguments,
+} from '../value.mts';
+import {
+  CreateBuiltinFunction,
+  ToNumber,
+  F, R,
+  Realm,
+} from '../abstract-ops/all.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-math.abs */
+function Math_abs([x = Value.undefined]: Arguments): ExpressionCompletion {
+  const n = Q(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): ExpressionCompletion {
+  const n = Q(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): ExpressionCompletion {
+  // 1. Set base to ? ToNumber(base).
+  base = Q(ToNumber(base));
+  // 2. Set exponent to ? ToNumber(exponent).
+  exponent = Q(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-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],
+  ], 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 = (args: Arguments): ExpressionCompletion => {
+      const nextArgs: number[] = [];
+      for (let i = 0; i < args.length; i += 1) {
+        nextArgs[i] = R(Q(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);
+    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,82 @@
+import {
+  surroundingAgent,
+} from '../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 ExpressionCompletion } from '../completion.mts';
+import { captureStack } from '../helpers.mts';
+import { bootstrapConstructor, bootstrapPrototype } from './bootstrap.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 = ([message = Value.undefined, options = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext): ExpressionCompletion => {
+      // 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(OrdinaryCreateFromConstructor(newTarget as FunctionObject, `%${name}.prototype%`, ['ErrorData']));
+      // 3. If message is not undefined, then
+      if (message !== Value.undefined) {
+        // a. Let msg be ? ToString(message).
+        const msg = Q(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(InstallErrorCause(O, options));
+      // NON-SPEC
+      X(captureStack(O));
+      // 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 ExpressionCompletion } 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): ExpressionCompletion {
+  let n;
+  if (value !== undefined) {
+    const prim = Q(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 = 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;
+}