@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/abstract-ops/data-types-and-values.mts

@@ -0,0 +1,43 @@
+import { JSStringValue, UndefinedValue, Value } from '../value.mts';
+import { X } from '../completion.mts';
+import { CanonicalNumericIndexString, R } from './all.mts';
+
+// This file covers predicates defined in
+/** https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values */
+
+// 6.1.7 #integer-index
+export function isIntegerIndex(V: Value) {
+  if (!(V instanceof JSStringValue)) {
+    return false;
+  }
+  const numeric = X(CanonicalNumericIndexString(V));
+  if (numeric instanceof UndefinedValue) {
+    return false;
+  }
+  if (Object.is(R(numeric), +0)) {
+    return true;
+  }
+  return R(numeric) > 0 && Number.isSafeInteger(R(numeric));
+}
+
+// 6.1.7 #array-index
+export function isArrayIndex(V: Value) {
+  if (!(V instanceof JSStringValue)) {
+    return false;
+  }
+  const numeric = X(CanonicalNumericIndexString(V));
+  if (numeric instanceof UndefinedValue) {
+    return false;
+  }
+  if (!Number.isInteger(R(numeric))) {
+    return false;
+  }
+  if (Object.is(R(numeric), +0)) {
+    return true;
+  }
+  return R(numeric) > 0 && R(numeric) < (2 ** 32) - 1;
+}
+
+export function isNonNegativeInteger(argument: number) {
+  return Number.isInteger(argument) && argument >= 0;
+}

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

@@ -0,0 +1,149 @@
+import { Q } from '../completion.mts';
+import { surroundingAgent } from '../host-defined/engine.mts';
+import { __ts_cast__ } from '../helpers.mts';
+import type { DataViewObject } from '../intrinsics/DataView.mts';
+import { type TypedArrayTypes, typedArrayInfoByType } from '../intrinsics/TypedArray.mts';
+import { Value } from '../value.mts';
+import {
+  Assert,
+  GetValueFromBuffer,
+  IsDetachedBuffer,
+  IsBigIntElementType,
+  SetValueInBuffer,
+  ToBoolean,
+  ToIndex,
+  ToNumber,
+  ToBigInt,
+  RequireInternalSlot,
+  type ArrayBufferObject,
+  ArrayBufferByteLength,
+  IsFixedLengthArrayBuffer,
+} from './all.mts';
+
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-dataview-objects */
+
+/** https://tc39.es/ecma262/#sec-dataview-with-buffer-witness-records */
+export interface DataViewWithBufferWitnessRecord {
+  readonly Object: DataViewObject;
+  CachedBufferByteLength: number | 'detached';
+}
+
+/** https://tc39.es/ecma262/#sec-makedataviewwithbufferwitnessrecord */
+export function MakeDataViewWithBufferWitnessRecord(obj: DataViewObject, order: 'seq-cst' | 'unordered'): DataViewWithBufferWitnessRecord {
+  const buffer = obj.ViewedArrayBuffer as ArrayBufferObject;
+  let byteLength: DataViewWithBufferWitnessRecord['CachedBufferByteLength'];
+  if (IsDetachedBuffer(buffer)) {
+    byteLength = 'detached';
+  } else {
+    byteLength = ArrayBufferByteLength(buffer, order);
+  }
+  return { Object: obj, CachedBufferByteLength: byteLength };
+}
+
+/** https://tc39.es/ecma262/#sec-getviewbytelength */
+export function GetViewByteLength(viewRecord: DataViewWithBufferWitnessRecord): number {
+  Assert(!IsViewOutOfBounds(viewRecord));
+  const view = viewRecord.Object;
+  // @ts-expect-error
+  if (view.ByteLength !== 'auto') {
+    return view.ByteLength;
+  }
+  Assert(!IsFixedLengthArrayBuffer(view.ViewedArrayBuffer as ArrayBufferObject));
+  const byteOffset = view.ByteOffset;
+  const byteLength = viewRecord.CachedBufferByteLength;
+  Assert(byteLength !== 'detached');
+  return byteLength - byteOffset;
+}
+
+/** https://tc39.es/ecma262/#sec-isviewoutofbounds */
+export function IsViewOutOfBounds(viewRecord: DataViewWithBufferWitnessRecord): boolean {
+  const view = viewRecord.Object;
+  const bufferByteLength = viewRecord.CachedBufferByteLength;
+  if (IsDetachedBuffer(view.ViewedArrayBuffer as ArrayBufferObject)) {
+    Assert(bufferByteLength === 'detached');
+    return true;
+  }
+  Assert(typeof bufferByteLength === 'number' && bufferByteLength >= 0);
+  const byteOffsetStart = view.ByteOffset;
+  let byteOffsetEnd;
+  // @ts-expect-error
+  if (view.ByteLength === 'auto') {
+    byteOffsetEnd = bufferByteLength;
+  } else {
+    byteOffsetEnd = byteOffsetStart + view.ByteLength;
+  }
+  if (byteOffsetStart > bufferByteLength || byteOffsetEnd > bufferByteLength) {
+    return true;
+  }
+  return false;
+}
+
+/** https://tc39.es/ecma262/#sec-getviewvalue */
+export function* GetViewValue(view: Value, requestIndex: Value, isLittleEndian: Value, type: TypedArrayTypes) {
+  // 1. Perform ? RequireInternalSlot(view, [[DataView]]).
+  Q(RequireInternalSlot(view, 'DataView'));
+  __ts_cast__<DataViewObject>(view);
+  // 2. Assert: view has a [[ViewedArrayBuffer]] internal slot.
+  Assert('ViewedArrayBuffer' in view);
+  // 3. Let getIndex be ? ToIndex(requestIndex).
+  const getIndex = Q(yield* ToIndex(requestIndex));
+  // 4. Set isLittleEndian to ToBoolean(isLittleEndian).
+  isLittleEndian = ToBoolean(isLittleEndian);
+  // 7. Let viewOffset be view.[[ByteOffset]].
+  const viewOffset = view.ByteOffset;
+  const viewRecord = MakeDataViewWithBufferWitnessRecord(view, 'unordered');
+  if (IsViewOutOfBounds(viewRecord)) {
+    return surroundingAgent.Throw('TypeError', 'DataViewOOB');
+  }
+  const viewSize = GetViewByteLength(viewRecord);
+  // 9. Let elementSize be the Element Size value specified in Table 61 for Element Type type.
+  const elementSize = typedArrayInfoByType[type].ElementSize;
+  // 10. If getIndex + elementSize > viewSize, throw a RangeError exception.
+  if (getIndex + elementSize > viewSize) {
+    return surroundingAgent.Throw('RangeError', 'DataViewOOB');
+  }
+  // 11. Let bufferIndex be getIndex + viewOffset.
+  const bufferIndex = getIndex + viewOffset;
+  // 12. Return GetValueFromBuffer(buffer, bufferIndex, type, false, Unordered, isLittleEndian).
+  return GetValueFromBuffer(view.ViewedArrayBuffer as ArrayBufferObject, bufferIndex, type, false, 'unordered', isLittleEndian);
+}
+
+/** https://tc39.es/ecma262/#sec-setviewvalue */
+export function* SetViewValue(view: Value, requestIndex: Value, isLittleEndian: Value, type: TypedArrayTypes, value: Value) {
+  // 1. Perform ? RequireInternalSlot(view, [[DataView]]).
+  Q(RequireInternalSlot(view, 'DataView'));
+  // 2. Assert: view has a [[ViewedArrayBuffer]] internal slot.
+  Assert('ViewedArrayBuffer' in view);
+  __ts_cast__<DataViewObject>(view);
+  // 3. Let getIndex be ? ToIndex(requestIndex).
+  const getIndex = Q(yield* ToIndex(requestIndex));
+  // 4. If IsBigIntElementType(type) is true, let numberValue be ? ToBigInt(value).
+  // 5. Otherwise, let numberValue be ? ToNumber(value).
+  let numberValue;
+  if (IsBigIntElementType(type) === Value.true) {
+    numberValue = Q(yield* ToBigInt(value));
+  } else {
+    numberValue = Q(yield* ToNumber(value));
+  }
+  // 6. Set isLittleEndian to ToBoolean(isLittleEndian).
+  isLittleEndian = ToBoolean(isLittleEndian);
+  // 9. Let viewOffset be view.[[ByteOffset]].
+  const viewOffset = view.ByteOffset;
+  const viewRecord = MakeDataViewWithBufferWitnessRecord(view, 'unordered');
+  if (IsViewOutOfBounds(viewRecord)) {
+    return surroundingAgent.Throw('TypeError', 'DataViewOOB');
+  }
+  const viewSize = GetViewByteLength(viewRecord);
+  // 11. Let elementSize be the Element Size value specified in Table 61 for Element Type type.
+  const elementSize = typedArrayInfoByType[type].ElementSize;
+  // 12. If getIndex + elementSize > viewSize, throw a RangeError exception.
+  if (getIndex + elementSize > viewSize) {
+    return surroundingAgent.Throw('RangeError', 'DataViewOOB');
+  }
+  // 13. Let bufferIndex be getIndex + viewOffset.
+  const bufferIndex = getIndex + viewOffset;
+  // 14. Perform ? SetValueInBuffer(buffer, bufferIndex, type, numberValue, false, Unordered, isLittleEndian).
+  Q(yield* SetValueInBuffer(view.ViewedArrayBuffer as ArrayBufferObject, bufferIndex, type, numberValue, false, 'unordered', isLittleEndian));
+  return Value.undefined;
+}

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

@@ -0,0 +1,232 @@
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-date-objects */
+
+import { X } from '../completion.mts';
+import {
+  ToIntegerOrInfinity,
+  F, R,
+  Assert,
+} from './all.mts';
+import type { NumberValue } from '#self';
+
+const mod = (n: number, m: number) => {
+  const r = n % m;
+  return Math.floor(r >= 0 ? r : r + m);
+};
+
+export const HoursPerDay = 24;
+export const MinutesPerHour = 60;
+export const SecondsPerMinute = 60;
+export const msPerSecond = 1000;
+export const msPerMinute = msPerSecond * SecondsPerMinute;
+export const msPerHour = msPerMinute * MinutesPerHour;
+export const msPerDay = msPerHour * HoursPerDay;
+
+/** https://tc39.es/ecma262/#sec-day-number-and-time-within-day */
+export function Day(t: NumberValue) {
+  return F(Math.floor(R(t) / msPerDay));
+}
+
+export function TimeWithinDay(t: NumberValue) {
+  return F(mod(R(t), msPerDay));
+}
+
+/** https://tc39.es/ecma262/#sec-year-number */
+export function DaysInYear(y: NumberValue) {
+  const ry = R(y);
+  if (mod(ry, 400) === 0) {
+    return F(366);
+  }
+  if (mod(ry, 100) === 0) {
+    return F(365);
+  }
+  if (mod(ry, 4) === 0) {
+    return F(366);
+  }
+  return F(365);
+}
+
+export function DayFromYear(_y: NumberValue) {
+  const y = R(_y);
+  return F(365 * (y - 1970) + Math.floor((y - 1969) / 4) - Math.floor((y - 1901) / 100) + Math.floor((y - 1601) / 400));
+}
+
+export function TimeFromYear(y: NumberValue) {
+  return F(msPerDay * R(DayFromYear(y)));
+}
+
+export const msPerAverageYear = 12 * 30.436875 * msPerDay;
+
+export function YearFromTime(_t: NumberValue) {
+  const t = R(_t);
+  let year = Math.floor((t + msPerAverageYear / 2) / msPerAverageYear) + 1970;
+  if (R(TimeFromYear(F(year))) > t) {
+    year -= 1;
+  }
+  return F(year);
+}
+
+export function InLeapYear(t: NumberValue) {
+  if (R(DaysInYear(YearFromTime(t))) === 366) {
+    return F(1);
+  }
+  return F(0);
+}
+
+/** https://tc39.es/ecma262/#sec-month-number */
+export function MonthFromTime(t: NumberValue) {
+  const inLeapYear = R(InLeapYear(t));
+  const dayWithinYear = R(DayWithinYear(t));
+  if (dayWithinYear < 31) {
+    return F(+0);
+  }
+  if (dayWithinYear < 59 + inLeapYear) {
+    return F(1);
+  }
+  if (dayWithinYear < 90 + inLeapYear) {
+    return F(2);
+  }
+  if (dayWithinYear < 120 + inLeapYear) {
+    return F(3);
+  }
+  if (dayWithinYear < 151 + inLeapYear) {
+    return F(4);
+  }
+  if (dayWithinYear < 181 + inLeapYear) {
+    return F(5);
+  }
+  if (dayWithinYear < 212 + inLeapYear) {
+    return F(6);
+  }
+  if (dayWithinYear < 243 + inLeapYear) {
+    return F(7);
+  }
+  if (dayWithinYear < 273 + inLeapYear) {
+    return F(8);
+  }
+  if (dayWithinYear < 304 + inLeapYear) {
+    return F(9);
+  }
+  if (dayWithinYear < 334 + inLeapYear) {
+    return F(10);
+  }
+  Assert(dayWithinYear < 365 + inLeapYear);
+  return F(11);
+}
+
+export function DayWithinYear(t: NumberValue) {
+  return F(R(Day(t)) - R(DayFromYear(YearFromTime(t))));
+}
+
+/** https://tc39.es/ecma262/#sec-date-number */
+export function DateFromTime(t: NumberValue) {
+  const inLeapYear = R(InLeapYear(t));
+  const dayWithinYear = R(DayWithinYear(t));
+  const month = R(MonthFromTime(t));
+  switch (month) {
+    case 0: return F(dayWithinYear + 1);
+    case 1: return F(dayWithinYear - 30);
+    case 2: return F(dayWithinYear - 58 - inLeapYear);
+    case 3: return F(dayWithinYear - 89 - inLeapYear);
+    case 4: return F(dayWithinYear - 119 - inLeapYear);
+    case 5: return F(dayWithinYear - 150 - inLeapYear);
+    case 6: return F(dayWithinYear - 180 - inLeapYear);
+    case 7: return F(dayWithinYear - 211 - inLeapYear);
+    case 8: return F(dayWithinYear - 242 - inLeapYear);
+    case 9: return F(dayWithinYear - 272 - inLeapYear);
+    case 10: return F(dayWithinYear - 303 - inLeapYear);
+    default:
+  }
+  Assert(month === 11);
+  return F(dayWithinYear - 333 - inLeapYear);
+}
+
+/** https://tc39.es/ecma262/#sec-week-day */
+export function WeekDay(t: NumberValue) {
+  return F(mod(R(Day(t)) + 4, 7));
+}
+
+/** https://tc39.es/ecma262/#sec-local-time-zone-adjustment */
+export function LocalTZA(_t: NumberValue, _isUTC: boolean) {
+  // TODO: implement this function properly.
+  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: NumberValue) {
+  return F(mod(Math.floor(R(t) / msPerHour), HoursPerDay));
+}
+
+export function MinFromTime(t: NumberValue) {
+  return F(mod(Math.floor(R(t) / msPerMinute), MinutesPerHour));
+}
+
+export function SecFromTime(t: NumberValue) {
+  return F(mod(Math.floor(R(t) / msPerSecond), SecondsPerMinute));
+}
+
+export function msFromTime(t: NumberValue) {
+  return F(mod(R(t), msPerSecond));
+}
+
+/** https://tc39.es/ecma262/#sec-maketime */
+export function MakeTime(hour: NumberValue, min: NumberValue, sec: NumberValue, ms: NumberValue) {
+  if (!Number.isFinite(R(hour)) || !Number.isFinite(R(min)) || !Number.isFinite(R(sec)) || !Number.isFinite(R(ms))) {
+    return F(NaN);
+  }
+  const h = X(ToIntegerOrInfinity(hour));
+  const m = X(ToIntegerOrInfinity(min));
+  const s = X(ToIntegerOrInfinity(sec));
+  const milli = X(ToIntegerOrInfinity(ms));
+  const t = h * msPerHour + m * msPerMinute + s * msPerSecond + milli;
+  return F(t);
+}
+
+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: NumberValue, month: NumberValue, date: NumberValue) {
+  if (!Number.isFinite(R(year)) || !Number.isFinite(R(month)) || !Number.isFinite(R(date))) {
+    return F(NaN);
+  }
+  const y = X(ToIntegerOrInfinity(year));
+  const m = X(ToIntegerOrInfinity(month));
+  const dt = X(ToIntegerOrInfinity(date));
+  const ym = y + Math.floor(m / 12);
+  const mn = mod(m, 12);
+  const ymday = R(DayFromYear(F(ym + (mn > 1 ? 1 : 0)))) - 365 * (mn > 1 ? 1 : 0) + daysWithinYearToEndOfMonth[mn];
+  const t = F(ymday * msPerDay);
+  return F(R(Day(t)) + dt - 1);
+}
+
+/** https://tc39.es/ecma262/#sec-makedate */
+export function MakeDate(day: NumberValue, time: NumberValue) {
+  if (!Number.isFinite(R(day)) || !Number.isFinite(R(time))) {
+    return F(NaN);
+  }
+  return F(R(day) * msPerDay + R(time));
+}
+
+/** https://tc39.es/ecma262/#sec-timeclip */
+export function TimeClip(time: NumberValue) {
+  // 1. If time is not finite, return NaN.
+  if (!time.isFinite()) {
+    return F(NaN);
+  }
+  // 2. If abs(ℝ(time)) > 8.64 × 1015, return NaN.
+  if (Math.abs(R(time)) > 8.64e15) {
+    return F(NaN);
+  }
+  // 3. Return 𝔽(! ToIntegerOrInfinity(time)).
+  return F(X(ToIntegerOrInfinity(time)));
+}

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,80 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  GetIdentifierReference,
+  EnvironmentRecord,
+  type EnvironmentRecordWithThisBinding,
+} from '../environment.mts';
+import { __ts_cast__ } from '../helpers.mts';
+import {
+  JSStringValue, NullValue, ObjectValue, UndefinedValue, Value,
+} from '../value.mts';
+import { Assert } from './all.mts';
+
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-execution-contexts */
+
+/** https://tc39.es/ecma262/#sec-getactivescriptormodule */
+export function GetActiveScriptOrModule() {
+  for (let i = surroundingAgent.executionContextStack.length - 1; i >= 0; i -= 1) {
+    const e = surroundingAgent.executionContextStack[i];
+    if (e.ScriptOrModule !== Value.null) {
+      return e.ScriptOrModule;
+    }
+  }
+  return Value.null;
+}
+
+/** https://tc39.es/ecma262/#sec-resolvebinding */
+export function ResolveBinding(name: JSStringValue, env?: EnvironmentRecord | UndefinedValue | NullValue, strict?: boolean) {
+  // 1. If env is not present or if env is undefined, then
+  if (env === undefined || env === Value.undefined) {
+    // a. Set env to the running execution context's LexicalEnvironment.
+    env = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  }
+  // 2. Assert: env is an Environment Record.
+  Assert(env instanceof EnvironmentRecord);
+  // 3. If the code matching the syntactic production that is being evaluated is contained in strict mode code, let strict be true; else let strict be false.
+  // 4. Return ? GetIdentifierReference(env, name, strict).
+  return GetIdentifierReference(env, name, strict ? Value.true : Value.false);
+}
+
+/** https://tc39.es/ecma262/#sec-getthisenvironment */
+export function GetThisEnvironment(): EnvironmentRecordWithThisBinding {
+  // 1. Let env be the running execution context's LexicalEnvironment.
+  let env = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 2. Repeat,
+  while (true) {
+    __ts_cast__<EnvironmentRecord>(env);
+    // a. Let exists be env.HasThisBinding().
+    const exists = env.HasThisBinding();
+    // b. If exists is true, return envRec.
+    if (exists === Value.true) {
+      return env as EnvironmentRecordWithThisBinding;
+    }
+    // c. Let outer be env.[[OuterEnv]].
+    const outer = env.OuterEnv;
+    // d. Assert: outer is not null.
+    Assert(!(outer instanceof NullValue));
+    // e. Set env to outer.
+    env = outer;
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-resolvethisbinding */
+export function ResolveThisBinding() {
+  const envRec = GetThisEnvironment();
+  return envRec.GetThisBinding();
+}
+
+/** https://tc39.es/ecma262/#sec-getnewtarget */
+export function GetNewTarget(): ObjectValue | UndefinedValue {
+  const envRec = GetThisEnvironment();
+  Assert('NewTarget' in envRec);
+  return envRec.NewTarget;
+}
+
+/** https://tc39.es/ecma262/#sec-getglobalobject */
+export function GetGlobalObject() {
+  const currentRealm = surroundingAgent.currentRealmRecord;
+  return currentRealm.GlobalObject;
+}