@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/abstract-ops/date-objects.mts

@@ -0,0 +1,226 @@
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-date-objects */
+
+import { X } from '../completion.mts';
+import {
+  ToIntegerOrInfinity,
+  F, R,
+  Assert,
+  type Integer,
+  type IntegralNumber,
+  type NaN,
+  type Num,
+} from './all.mts';
+import { floorDiv, modulo } from './math.mts';
+import { mark_OtherCalendarNotImplemented } from './temporal/not-implemented.mts';
+import { NumberValue } from '#self';
+
+/** https://tc39.es/ecma262/pr/3759/#sec-time-values-and-time-range */
+export type FiniteTimeValue = IntegralNumber;
+export type TimeValue = FiniteTimeValue | NaN;
+export const HoursPerDay = 24n;
+export const MinutesPerHour = 60n;
+export const SecondsPerMinute = 60n;
+export const msPerSecond = 1000n;
+export const nsPerSecond = 10n ** 9n;
+export const nsPerMillisecond = 10n ** 6n;
+export const nsPerMicrosecond = 10n ** 3n;
+export const msPerMinute = msPerSecond * SecondsPerMinute;
+export const msPerHour = msPerMinute * MinutesPerHour;
+export const msPerDay = msPerHour * HoursPerDay;
+export const NanosecondsPerDay = 10n ** 6n * msPerDay;
+export const MaxEpochNanoseconds = 10n ** 8n * NanosecondsPerDay;
+export const MinEpochNanoseconds = -MaxEpochNanoseconds;
+export const msPerAverageYear = 12 * 30.436875 * Number(msPerDay);
+
+/** https://tc39.es/ecma262/#sec-day-number-and-time-within-day */
+export function Day(t: FiniteTimeValue): Integer {
+  return floorDiv(BigInt(t), msPerDay);
+}
+
+export function TimeWithinDay(t: FiniteTimeValue): Integer {
+  return modulo(BigInt(t), msPerDay);
+}
+
+/** https://tc39.es/ecma262/#sec-dayfromyear */
+export function DayFromYear(y: Integer): Integer {
+  const numYears1 = y - 1970n;
+  const numYears4 = floorDiv(y - 1969n, 4n);
+  const numYears100 = floorDiv(y - 1901n, 100n);
+  const numYears400 = floorDiv(y - 1601n, 400n);
+  return 365n * numYears1 + numYears4 - numYears100 + numYears400;
+}
+
+export function TimeFromYear(y: Integer): TimeValue {
+  return Number(msPerDay * DayFromYear(y)) as TimeValue;
+}
+
+export function YearFromTime(t: FiniteTimeValue): Integer {
+  let year = BigInt(Math.floor(((t + msPerAverageYear / 2) / msPerAverageYear) + 1970));
+  if (TimeFromYear(year) > t) {
+    year -= 1n;
+  }
+  return year;
+}
+
+export function DayWithinYear(t: FiniteTimeValue): Integer {
+  return Day(t) - DayFromYear(YearFromTime(t));
+}
+
+export function InLeapYear(t: FiniteTimeValue): 0n | 1n {
+  const y = YearFromTime(t);
+  if (modulo(y, 400n) === 0n) return 1n;
+  if (modulo(y, 100n) === 0n) return 0n;
+  if (modulo(y, 4n) === 0n) return 1n;
+  return 0n;
+}
+
+/** https://tc39.es/ecma262/#sec-month-number */
+export function MonthFromTime(t: FiniteTimeValue): Integer {
+  const inLeapYear = InLeapYear(t);
+  const dayWithinYear = DayWithinYear(t);
+  if (dayWithinYear < 31n) return 0n;
+  if (dayWithinYear < 59n + inLeapYear) return 1n;
+  if (dayWithinYear < 90n + inLeapYear) return 2n;
+  if (dayWithinYear < 120n + inLeapYear) return 3n;
+  if (dayWithinYear < 151n + inLeapYear) return 4n;
+  if (dayWithinYear < 181n + inLeapYear) return 5n;
+  if (dayWithinYear < 212n + inLeapYear) return 6n;
+  if (dayWithinYear < 243n + inLeapYear) return 7n;
+  if (dayWithinYear < 273n + inLeapYear) return 8n;
+  if (dayWithinYear < 304n + inLeapYear) return 9n;
+  if (dayWithinYear < 334n + inLeapYear) return 10n;
+  Assert(dayWithinYear < 365n + inLeapYear);
+  return 11n;
+}
+
+/** https://tc39.es/ecma262/#sec-date-number */
+export function DateFromTime(t: FiniteTimeValue): Integer {
+  const inLeapYear = InLeapYear(t);
+  const dayWithinYear = DayWithinYear(t);
+  const month = MonthFromTime(t);
+  switch (month) {
+    case 0n: return dayWithinYear + 1n;
+    case 1n: return dayWithinYear - 30n;
+    case 2n: return dayWithinYear - 58n - inLeapYear;
+    case 3n: return dayWithinYear - 89n - inLeapYear;
+    case 4n: return dayWithinYear - 119n - inLeapYear;
+    case 5n: return dayWithinYear - 150n - inLeapYear;
+    case 6n: return dayWithinYear - 180n - inLeapYear;
+    case 7n: return dayWithinYear - 211n - inLeapYear;
+    case 8n: return dayWithinYear - 242n - inLeapYear;
+    case 9n: return dayWithinYear - 272n - inLeapYear;
+    case 10n: return dayWithinYear - 303n - inLeapYear;
+    default:
+  }
+  Assert(month === 11n);
+  return dayWithinYear - 333n - inLeapYear;
+}
+
+/** https://tc39.es/ecma262/#sec-week-day */
+export function WeekDay(t: FiniteTimeValue): Integer {
+  return modulo(Day(t) + 4n, 7n);
+}
+
+/** https://tc39.es/ecma262/#sec-local-time-zone-adjustment */
+// remove after Temporal merged
+export function LocalTZA(_t: NumberValue, _isUTC: boolean) {
+  mark_OtherCalendarNotImplemented();
+  return 0;
+}
+
+/** https://tc39.es/ecma262/#sec-localtime */
+export function LocalTime(t: NumberValue) {
+  return F(R(t) + LocalTZA(t, true));
+}
+
+/** https://tc39.es/ecma262/#sec-utc-t */
+export function UTC(t: NumberValue) {
+  return F(R(t) - LocalTZA(t, false));
+}
+
+/** https://tc39.es/ecma262/#sec-hours-minutes-second-and-milliseconds */
+export function HourFromTime(t: FiniteTimeValue): Integer {
+  return modulo(floorDiv(BigInt(t), msPerHour), HoursPerDay);
+}
+
+export function MinFromTime(t: FiniteTimeValue): Integer {
+  return modulo(floorDiv(BigInt(t), msPerMinute), MinutesPerHour);
+}
+
+export function SecFromTime(t: FiniteTimeValue): Integer {
+  return modulo(floorDiv(BigInt(t), msPerSecond), SecondsPerMinute);
+}
+
+export function MillisecFromTime(t: FiniteTimeValue): Integer {
+  return modulo(BigInt(t), msPerSecond);
+}
+
+/** https://tc39.es/ecma262/#sec-maketime */
+export function MakeTime(hour: Num, min: Num, sec: Num, ms: Num): Num {
+  if (!Number.isFinite(hour) || !Number.isFinite(min) || !Number.isFinite(sec) || !Number.isFinite(ms)) {
+    return NaN;
+  }
+  const h = X(ToIntegerOrInfinity(hour));
+  const m = X(ToIntegerOrInfinity(min));
+  const s = X(ToIntegerOrInfinity(sec));
+  const milli = X(ToIntegerOrInfinity(ms));
+  return ((h * Number(msPerHour) + m * Number(msPerMinute)) + s * Number(msPerSecond)) + milli;
+}
+
+const daysWithinYearToEndOfMonth = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365];
+
+/** https://tc39.es/ecma262/#sec-makeday */
+export function MakeDay(year: Num, month: Num, date: Num): Num | NaN {
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(date)) {
+    return NaN;
+  }
+  const y = X(ToIntegerOrInfinity(year));
+  const m = X(ToIntegerOrInfinity(month));
+  const dt = X(ToIntegerOrInfinity(date));
+  const ym = y + Math.floor(m / 12);
+  if (!Number.isFinite(ym)) return NaN;
+  const mn = modulo(m, 12);
+  // Find a finite time value t such that YearFromTime(t) = ℝ(ym), MonthFromTime(t) = mn, and DateFromTime(t) = 1; but if this is not possible (because some argument is out of range), return NaN.
+  const ymday = Number(DayFromYear(BigInt(ym + (mn > 1 ? 1 : 0)))) - 365 * (mn > 1 ? 1 : 0) + daysWithinYearToEndOfMonth[mn];
+  const t = Math.floor(ymday * Number(msPerDay));
+  if (!Number.isFinite(t)) return NaN;
+  return Number(Day(t)) + dt - 1;
+}
+
+/** https://tc39.es/ecma262/#sec-makedate */
+export function MakeDate(day: Num, time: Num): Num | NaN {
+  if (!Number.isFinite(day) || !Number.isFinite(time)) {
+    return NaN;
+  }
+  const tv = day * Number(msPerDay) + time;
+  if (!Number.isFinite(tv)) {
+    return NaN;
+  }
+  return tv;
+}
+
+/** https://tc39.es/ecma262/#sec-makefullyear */
+export function MakeFullYear(year: NumberValue): IntegralNumber | NaN {
+  if (year.isNaN() || year.isInfinity()) return NaN;
+  const truncated = X(ToIntegerOrInfinity(year));
+  if (truncated >= 0 && truncated <= 99) {
+    return 1900 + truncated;
+  }
+  return truncated;
+}
+
+
+/** https://tc39.es/ecma262/#sec-timeclip */
+export function TimeClip(time: Num): TimeValue {
+  // 1. If time is not finite, return NaN.
+  if (!Number.isFinite(time)) {
+    return NaN;
+  }
+  // 2. If abs(ℝ(time)) > 8.64 × 1015, return NaN.
+  if (Math.abs(time) > 8.64e15) {
+    return NaN;
+  }
+  // 3. Return 𝔽(! ToIntegerOrInfinity(time)).
+  return X(ToIntegerOrInfinity(time));
+}

package/src/abstract-ops/disposable-operations.mts

@@ -0,0 +1,166 @@
+import {
+  Completion,
+  EnsureCompletion,
+  IfAbruptRejectPromise,
+  NormalCompletion,
+  Q,
+  ThrowCompletion,
+  X,
+  Await,
+  type ValueEvaluator,
+} from '../completion.mts';
+import type { Evaluator, PlainEvaluator } from '../evaluator.mts';
+import {
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  Assert,
+  Call,
+  Construct,
+  CreateBuiltinFunction,
+  CreateNonEnumerableDataPropertyOrThrow,
+  GetMethod,
+  intrinsics,
+  NewPromiseCapability,
+  Throw,
+  type Arguments,
+  type FunctionObject,
+} from '#self';
+
+export type DisposableResourceKind = 'sync-dispose' | 'async-dispose';
+
+export interface DisposableResourceRecord {
+  readonly ResourceValue: ObjectValue | UndefinedValue;
+  readonly Kind: DisposableResourceKind;
+  readonly DisposeMethod: FunctionObject | UndefinedValue;
+}
+
+
+/** https://tc39.es/ecma262/#sec-adddisposableresource */
+export function* AddDisposableResource(
+  disposableResourceStack: DisposableResourceRecord[],
+  value: Value,
+  kind: DisposableResourceKind,
+  method?: FunctionObject,
+): PlainEvaluator<void> {
+  let resource: DisposableResourceRecord;
+  if (method !== undefined) {
+    Assert(value === Value.undefined);
+    resource = Q(yield* CreateDisposableResource(Value.undefined, kind, method));
+  } else {
+    if ((value === Value.null || value === Value.undefined) && kind === 'sync-dispose') {
+      return;
+    }
+    resource = Q(yield* CreateDisposableResource(value, kind));
+  }
+  disposableResourceStack.push(resource);
+  return undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-createdisposableresource */
+export function* CreateDisposableResource(
+  _value: Value,
+  kind: DisposableResourceKind,
+  _method?: FunctionObject,
+): PlainEvaluator<DisposableResourceRecord> {
+  let value: ObjectValue | UndefinedValue;
+  let method: FunctionObject | UndefinedValue;
+  if (_method === undefined) {
+    if (_value === Value.null || _value === Value.undefined) {
+      value = Value.undefined;
+      method = Value.undefined;
+    } else {
+      method = Q(yield* GetDisposeMethod(_value, kind));
+      if (method === Value.undefined) {
+        return Throw.TypeError('$1 is not a function', method);
+      }
+      value = _value as ObjectValue;
+    }
+  } else {
+    Assert(_value === Value.undefined);
+    value = Value.undefined;
+    method = _method;
+  }
+  return { ResourceValue: value!, Kind: kind, DisposeMethod: method! };
+}
+
+/** https://tc39.es/ecma262/#sec-getdisposemethod */
+export function* GetDisposeMethod(value: Value, kind: DisposableResourceKind): ValueEvaluator<FunctionObject | UndefinedValue> {
+  if (!(value instanceof ObjectValue)) {
+    return Throw.TypeError('$1 is not an object', value);
+  }
+  if (kind === 'sync-dispose') {
+    return Q(yield* GetMethod(value, wellKnownSymbols.dispose));
+  }
+  Assert(kind === 'async-dispose');
+  const asyncMethod = Q(yield* GetMethod(value, wellKnownSymbols.asyncDispose));
+  if (asyncMethod !== Value.undefined) {
+    return asyncMethod;
+  }
+  const syncMethod = Q(yield* GetMethod(value, wellKnownSymbols.dispose));
+  if (syncMethod === Value.undefined) {
+    return Value.undefined;
+  }
+  const closure = function* closure(_args: Arguments, { thisValue }: FunctionCallContext) {
+    const obj = thisValue;
+    const promiseCapability = X(NewPromiseCapability(intrinsics()['%Promise%']));
+    const result = yield* Call(syncMethod, obj);
+    IfAbruptRejectPromise(result, promiseCapability);
+    X(Call(promiseCapability.Resolve, Value.undefined, [Value.undefined]));
+    return promiseCapability.Promise;
+  };
+  return CreateBuiltinFunction(closure, 0, Value(''), []);
+}
+
+/** https://tc39.es/ecma262/#sec-disposeresources */
+export function* DisposeResources<C extends Completion<unknown>>(
+  disposableResourceStack: DisposableResourceRecord[],
+  completion: C,
+): Evaluator<C | ThrowCompletion> {
+  let needsAwait = false;
+  let hasAwaited = false;
+  let outputCompletion: C | ThrowCompletion = completion;
+  for (const resource of disposableResourceStack.toReversed()) {
+    const value = resource.ResourceValue;
+    const kind = resource.Kind;
+    const method = resource.DisposeMethod;
+    if (kind === 'sync-dispose' && needsAwait && !hasAwaited) {
+      // note: do not remove yield* here, because X will skip async control flow
+      X(yield* Await(Value.undefined));
+      needsAwait = false;
+    }
+    if (method !== Value.undefined) {
+      let result = EnsureCompletion(yield* Call(method, value));
+      if (result instanceof NormalCompletion && kind === 'async-dispose') {
+        result = EnsureCompletion(yield* Await(result.Value));
+        hasAwaited = true;
+      }
+      if (result instanceof ThrowCompletion) {
+        if (outputCompletion instanceof ThrowCompletion) {
+          const result_ = result.Value;
+          const suppressed = outputCompletion.Value;
+          const error = X(Construct(intrinsics()['%SuppressedError%'], []));
+          CreateNonEnumerableDataPropertyOrThrow(error, Value('error'), result_);
+          CreateNonEnumerableDataPropertyOrThrow(error, Value('suppressed'), suppressed);
+          outputCompletion = ThrowCompletion(error);
+        } else {
+          outputCompletion = result;
+        }
+      }
+    } else {
+      Assert(kind === 'async-dispose');
+      needsAwait = true;
+    }
+  }
+  if (needsAwait && !hasAwaited) {
+    // note: do not remove yield* here, because X will skip async control flow
+    X(yield* Await(Value.undefined));
+  }
+  // Note: NOTE: At this point disposableResourceStack will never be used again. The contents of disposableResourceStack can be discarded in implementations, such as by garbage collection.
+  disposableResourceStack.length = 0;
+  return outputCompletion;
+}

package/src/abstract-ops/error-objects.mts

@@ -0,0 +1,38 @@
+import { ObjectValue, Value, Descriptor } from '../value.mts';
+import {
+  Q, X, NormalCompletion, type ValueEvaluator,
+} from '../completion.mts';
+import type { ErrorObject } from '../intrinsics/Error.mts';
+import { HasProperty, Get, DefinePropertyOrThrow } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-errorobjects-install-error-cause */
+export function* InstallErrorCause(O: ObjectValue, options: Value): ValueEvaluator {
+  // 1. If Type(options) is Object and ? HasProperty(options, "cause") is true, then
+  if (options instanceof ObjectValue) {
+    // nested if statement due to macro expansion
+    if (Q(yield* HasProperty(options, Value('cause'))) === Value.true) {
+      // a. Let cause be ? Get(options, "cause").
+      const cause = Q(yield* Get(options, Value('cause')));
+      // b. Perform ! CreateNonEnumerableDataPropertyOrThrow(O, "cause", cause).
+      X(DefinePropertyOrThrow(O, Value('cause'), Descriptor({
+        Value: cause,
+        Writable: Value.true,
+        Enumerable: Value.false,
+        Configurable: Value.true,
+      })));
+    }
+  }
+  // 2. Return NormalCompletion(undefined).
+  return NormalCompletion(Value.undefined);
+}
+
+/** https://tc39.es/proposal-is-error/#sec-iserror */
+export function IsError(argument: Value): argument is ErrorObject {
+  if (!(argument instanceof ObjectValue)) {
+    return false;
+  }
+  if ('ErrorData' in argument) {
+    return true;
+  }
+  return false;
+}

package/src/abstract-ops/execution-contexts.mts

@@ -0,0 +1,18 @@
+import { surroundingAgent, NullValue } from '#self';
+
+/** Used in the inspector infrastructure to track the real source (or compiled) */
+export function getActiveScriptId(): string | undefined {
+  for (let i = surroundingAgent.executionContextStack.length - 1; i >= 0; i -= 1) {
+    const e = surroundingAgent.executionContextStack[i];
+    if (e.HostDefined?.scriptId) {
+      return e.HostDefined.scriptId;
+    }
+    if (!(e.ScriptOrModule instanceof NullValue)) {
+      const fromScript = e.ScriptOrModule.HostDefined?.scriptId;
+      if (fromScript) {
+        return fromScript;
+      }
+    }
+  }
+  return undefined;
+}