@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

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

@@ -0,0 +1,402 @@
+import {
+  ObjectValue, Value, NumberValue,
+  JSStringValue,
+  type ObjectInternalMethods,
+  SymbolValue,
+  Descriptor,
+  UndefinedValue,
+  BooleanValue,
+} from '../value.mts';
+import {
+  Q, X, type ExpressionCompletion,
+} from '../completion.mts';
+import { __ts_cast__ } from '../helpers.mts';
+import {
+  type TypedArrayObject, TypedArrayElementSize, TypedArrayElementType,
+} from '../intrinsics/TypedArray.mts';
+import { isDataViewObject, type DataViewObject } from '../intrinsics/DataView.mts';
+import {
+  Assert,
+  IsDetachedBuffer,
+  R,
+  ArrayBufferByteLength,
+  IsFixedLengthArrayBuffer,
+  type ArrayBufferObject,
+  MakeBasicObject,
+  isIntegerIndex,
+  ToString,
+  OrdinaryDelete,
+  CanonicalNumericIndexString,
+  F,
+  IsAccessorDescriptor,
+  OrdinaryDefineOwnProperty,
+  OrdinaryGet,
+  OrdinaryGetOwnProperty,
+  OrdinaryHasProperty,
+  OrdinarySet,
+  GetValueFromBuffer,
+  SetValueInBuffer,
+  ToBigInt,
+  ToNumber,
+  IsSharedArrayBuffer,
+  OrdinaryPreventExtensions,
+  SameValue,
+  IsIntegralNumber,
+  IsViewOutOfBounds,
+  MakeDataViewWithBufferWitnessRecord,
+} from './all.mts';
+
+const InternalMethods = {
+  /** https://tc39.es/ecma262/#sec-typedarray-preventextensions */
+  PreventExtensions() {
+    const O = this;
+    if (!IsTypedArrayFixedLength(O)) {
+      return Value.false;
+    }
+    return OrdinaryPreventExtensions(O);
+  },
+  /** https://tc39.es/ecma262/#sec-typedarray-getownproperty */
+  GetOwnProperty(P) {
+    const O = this;
+    // 3. If Type(P) is String, then
+    if (P instanceof JSStringValue) {
+      // a. Let numericIndex be CanonicalNumericIndexString(P).
+      const numericIndex = CanonicalNumericIndexString(P);
+      // b. If numericIndex is not undefined, then
+      if (!(numericIndex instanceof UndefinedValue)) {
+        // i. Let value be TypedArrayGetElement(O, numericIndex).
+        const value = TypedArrayGetElement(O, numericIndex);
+        // ii. If value is undefined, return undefined.
+        if (value === Value.undefined) {
+          return Value.undefined;
+        }
+        // iii. Return the PropertyDescriptor { [[Value]]: value, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }.
+        return Descriptor({
+          Value: value,
+          Writable: Value.true,
+          Enumerable: Value.true,
+          Configurable: Value.true,
+        });
+      }
+    }
+    // 4. Return OrdinaryGetOwnProperty(O, P).
+    return OrdinaryGetOwnProperty(O, P);
+  },
+  /** https://tc39.es/ecma262/#sec-typedarray-hasproperty */
+  HasProperty(P) {
+    const O = this;
+    // 3. If Type(P) is String, then
+    if (P instanceof JSStringValue) {
+      // a. Let numericIndex be CanonicalNumericIndexString(P).
+      const numericIndex = CanonicalNumericIndexString(P);
+      // b. If numericIndex is not undefined, then
+      if (!(numericIndex instanceof UndefinedValue)) {
+        return IsValidIntegerIndex(O, numericIndex);
+      }
+    }
+    // 4. Return ? OrdinaryHasProperty(O, P)
+    return Q(OrdinaryHasProperty(O, P));
+  },
+  /** https://tc39.es/ecma262/#sec-typedarray-defineownproperty */
+  DefineOwnProperty(P, Desc) {
+    const O = this;
+    // 3. If Type(P) is String, then
+    if (P instanceof JSStringValue) {
+      // a. Let numericIndex be CanonicalNumericIndexString(P).
+      const numericIndex = CanonicalNumericIndexString(P);
+      // b. If numericIndex is not undefined, then
+      if (!(numericIndex instanceof UndefinedValue)) {
+        // i. If ! IsValidIntegerIndex(O, numericIndex) is false, return false.
+        if (IsValidIntegerIndex(O, numericIndex) === Value.false) {
+          return Value.false;
+        }
+        // iii. If Desc has a [[Configurable]] field and if Desc.[[Configurable]] is true, return false.
+        if (Desc.Configurable === Value.false) {
+          return Value.false;
+        }
+        // iv. If Desc has an [[Enumerable]] field and if Desc.[[Enumerable]] is false, return false.
+        if (Desc.Enumerable === Value.false) {
+          return Value.false;
+        }
+        // ii. If IsAccessorDescriptor(Desc) is true, return false.
+        if (IsAccessorDescriptor(Desc)) {
+          return Value.false;
+        }
+        // v. If Desc has a [[Writable]] field and if Desc.[[Writable]] is false, return false.
+        if (Desc.Writable === Value.false) {
+          return Value.false;
+        }
+        // vi. If Desc has a [[Value]] field, then
+        if (Desc.Value !== undefined) {
+          return Q(TypedArraySetElement(O, numericIndex, Desc.Value));
+        }
+        // vii. Return true.
+        return Value.true;
+      }
+    }
+    // 4. Return ! OrdinaryDefineOwnProperty(O, P, Desc).
+    return Q(OrdinaryDefineOwnProperty(O, P, Desc));
+  },
+  /** https://tc39.es/ecma262/#sec-typedarray-get */
+  Get(P, Receiver) {
+    const O = this;
+    // 2. If Type(P) is String, then
+    if (P instanceof JSStringValue) {
+      // a. Let numericIndex be CanonicalNumericIndexString(P).
+      const numericIndex = CanonicalNumericIndexString(P);
+      // b. If numericIndex is not undefined, then
+      if (!(numericIndex instanceof UndefinedValue)) {
+        // i. Return ! IntegerIndexedElementGet(O, numericIndex).
+        return X(TypedArrayGetElement(O, numericIndex));
+      }
+    }
+    // 3. Return ? OrdinaryGet(O, P, Receiver).
+    return Q(OrdinaryGet(O, P, Receiver));
+  },
+  /** https://tc39.es/ecma262/#sec-typedarray-set */
+  Set(P, V, Receiver) {
+    const O = this;
+    // 2. If Type(P) is String, then
+    if (P instanceof JSStringValue) {
+      // a. Let numericIndex be CanonicalNumericIndexString(P).
+      const numericIndex = CanonicalNumericIndexString(P);
+      // b. If numericIndex is not undefined, then
+      if (!(numericIndex instanceof UndefinedValue)) {
+        if (SameValue(O, Receiver) === Value.true) {
+          // i. Perform ? IntegerIndexedElementSet(O, numericIndex, V).
+          Q(TypedArraySetElement(O, numericIndex, V));
+          // ii. Return true.
+          return Value.true;
+        }
+        if (IsValidIntegerIndex(O, numericIndex) === Value.false) {
+          return Value.true;
+        }
+      }
+    }
+    // 3. Return ? OrdinarySet(O, P, V, Receiver).
+    return Q(OrdinarySet(O, P, V, Receiver));
+  },
+  /** https://tc39.es/ecma262/#sec-typedarray-delete */
+  Delete(P) {
+    const O = this;
+    // 3. If Type(P) is String, then
+    if (P instanceof JSStringValue) {
+      // a. Let numericIndex be ! CanonicalNumericIndexString(P).
+      const numericIndex = CanonicalNumericIndexString(P);
+      // b. If numericIndex is not undefined, then
+      if (!(numericIndex instanceof UndefinedValue)) {
+        // ii. If IsValidIntegerIndex(O, numericIndex) is false, return true.
+        if (IsValidIntegerIndex(O, numericIndex) === Value.false) {
+          return Value.true;
+        } else {
+          // iii. Return false.
+          return Value.false;
+        }
+      }
+    }
+    // 4. Return ? OrdinaryDelete(O, P).
+    return Q(OrdinaryDelete(O, P));
+  },
+  /** https://tc39.es/ecma262/#sec-typedarray-ownpropertykeys */
+  OwnPropertyKeys() {
+    const O = this;
+    const taRecord = MakeTypedArrayWithBufferWitnessRecord(O, 'seq-cst');
+    // 1. Let keys be a new empty List.
+    const keys = [];
+    if (!IsTypedArrayOutOfBounds(taRecord)) {
+      const length = TypedArrayLength(taRecord);
+      // 4. For each integer i starting with 0 such that i < len, in ascending order, do
+      for (let i = 0; i < length; i += 1) {
+        // a. Add ! ToString(𝔽(i)) as the last element of keys.
+        keys.push(X(ToString(F(i))));
+      }
+    }
+    // 5. For each own property key P of O such that Type(P) is String and P is not an integer index, in ascending chronological order of property creation, do
+    for (const P of O.properties.keys()) {
+      if (P instanceof JSStringValue) {
+        if (!isIntegerIndex(P)) {
+          // a. Add P as the last element of keys.
+          keys.push(P);
+        }
+      }
+    }
+    // 6. For each own property key P of O such that Type(P) is Symbol, in ascending chronological order of property creation, do
+    for (const P of O.properties.keys()) {
+      if (P instanceof SymbolValue) {
+        // a. Add P as the last element of keys.
+        keys.push(P);
+      }
+    }
+    // 7. Return keys.
+    return keys;
+  },
+} satisfies Partial<ObjectInternalMethods<TypedArrayObject>>;
+
+/** https://tc39.es/ecma262/#sec-typedarray-with-buffer-witness-records */
+export interface TypedArrayWithBufferWitnessRecord {
+  readonly Object: TypedArrayObject;
+  readonly CachedBufferByteLength: 'detached' | number;
+}
+
+/** https://tc39.es/ecma262/#sec-maketypedarraywithbufferwitnessrecord */
+export function MakeTypedArrayWithBufferWitnessRecord(obj: TypedArrayObject, order: 'seq-cst' | 'unordered') {
+  const buffer = obj.ViewedArrayBuffer;
+  let byteLength: TypedArrayWithBufferWitnessRecord['CachedBufferByteLength'];
+  if (IsDetachedBuffer(buffer as ArrayBufferObject) === Value.true) {
+    byteLength = 'detached';
+  } else {
+    byteLength = ArrayBufferByteLength(buffer as ArrayBufferObject, order);
+  }
+  return { Object: obj, CachedBufferByteLength: byteLength };
+}
+
+/** https://tc39.es/ecma262/#sec-typedarraycreate */
+export function TypedArrayCreate(prototype: ObjectValue) {
+  const internalSlotsList = ['Prototype', 'Extensible', 'ViewedArrayBuffer', 'TypedArrayName', 'ContentType', 'ByteLength', 'ByteOffset', 'ArrayLength'] as const;
+  const A = MakeBasicObject(internalSlotsList);
+  A.PreventExtensions = InternalMethods.PreventExtensions;
+  A.GetOwnProperty = InternalMethods.GetOwnProperty;
+  A.HasProperty = InternalMethods.HasProperty;
+  A.DefineOwnProperty = InternalMethods.DefineOwnProperty;
+  A.Get = InternalMethods.Get;
+  A.Set = InternalMethods.Set;
+  A.Delete = InternalMethods.Delete;
+  A.OwnPropertyKeys = InternalMethods.OwnPropertyKeys;
+  A.Prototype = prototype;
+  return A;
+}
+
+/** https://tc39.es/ecma262/#sec-typedarraybytelength */
+export function TypedArrayByteLength(taRecord: TypedArrayWithBufferWitnessRecord): number {
+  if (IsTypedArrayOutOfBounds(taRecord)) {
+    return 0;
+  }
+  const length = TypedArrayLength(taRecord);
+  if (length === 0) {
+    return 0;
+  }
+  const O = taRecord.Object;
+  if (O.ByteLength !== 'auto') {
+    return O.ByteLength;
+  }
+  const elementSize = TypedArrayElementSize(O);
+  return length * elementSize;
+}
+
+/** https://tc39.es/ecma262/#sec-typedarraylength */
+export function TypedArrayLength(taRecord: TypedArrayWithBufferWitnessRecord): number {
+  Assert(IsTypedArrayOutOfBounds(taRecord) === false);
+  const O = taRecord.Object;
+  if (O.ArrayLength !== 'auto') {
+    return O.ArrayLength;
+  }
+  Assert(!IsFixedLengthArrayBuffer(O.ViewedArrayBuffer as ArrayBufferObject));
+  const byteOffset = O.ByteOffset;
+  const elementSize = TypedArrayElementSize(O);
+  const bufferLength = taRecord.CachedBufferByteLength;
+  Assert(bufferLength !== 'detached');
+  return Math.floor((bufferLength - byteOffset) / elementSize);
+}
+
+/** https://tc39.es/ecma262/#sec-istypedarrayoutofbounds */
+export function IsTypedArrayOutOfBounds(taRecord: TypedArrayWithBufferWitnessRecord) {
+  const O = taRecord.Object;
+  const bufferByteLength = taRecord.CachedBufferByteLength;
+  Assert(
+    (IsDetachedBuffer(O.ViewedArrayBuffer as ArrayBufferObject) === Value.true && bufferByteLength === 'detached')
+    || (IsDetachedBuffer(O.ViewedArrayBuffer as ArrayBufferObject) === Value.false && bufferByteLength !== 'detached'),
+  );
+  if (bufferByteLength === 'detached') {
+    return true;
+  }
+  const byteOffsetStart = O.ByteOffset;
+  let byteOffsetEnd;
+  if (O.ArrayLength === 'auto') {
+    byteOffsetEnd = bufferByteLength;
+  } else {
+    const elementSize = TypedArrayElementSize(O);
+    byteOffsetEnd = byteOffsetStart + O.ArrayLength * elementSize;
+  }
+  if (byteOffsetStart > bufferByteLength || byteOffsetEnd > bufferByteLength) {
+    return true;
+  }
+  return false;
+}
+
+/** https://tc39.es/ecma262/#sec-istypedarrayfixedlength */
+export function IsTypedArrayFixedLength(O: TypedArrayObject) {
+  if (O.ArrayLength === 'auto') {
+    return false;
+  }
+  const buffer = O.ViewedArrayBuffer as ArrayBufferObject;
+  if (!IsFixedLengthArrayBuffer(buffer) && IsSharedArrayBuffer(buffer) === Value.false) {
+    return false;
+  }
+  return true;
+}
+
+/** https://tc39.es/ecma262/#sec-isvalidintegerindex */
+export function IsValidIntegerIndex(O: TypedArrayObject, index: NumberValue) {
+  if (IsDetachedBuffer(O.ViewedArrayBuffer as ArrayBufferObject) === Value.true) {
+    return Value.false;
+  }
+  if (IsIntegralNumber(index) === Value.false) {
+    return Value.false;
+  }
+  const index_ = R(index);
+  if (Object.is(index_, -0) || index_ < 0) {
+    return Value.false;
+  }
+  const taRecord = MakeTypedArrayWithBufferWitnessRecord(O, 'seq-cst');
+  if (IsTypedArrayOutOfBounds(taRecord)) {
+    return Value.false;
+  }
+  const length = TypedArrayLength(taRecord);
+  if (index_ >= length) {
+    return Value.false;
+  }
+  return Value.true;
+}
+
+/** https://tc39.es/ecma262/#sec-typedarraygetelement */
+export function TypedArrayGetElement(O: TypedArrayObject, index: NumberValue) {
+  if (IsValidIntegerIndex(O, index) === Value.false) {
+    return Value.undefined;
+  }
+  const offset = O.ByteOffset;
+  const elementSize = TypedArrayElementSize(O);
+  const byteIndexInBuffer = (R(index) * elementSize) + offset;
+  const elementType = TypedArrayElementType(O);
+  return GetValueFromBuffer(O.ViewedArrayBuffer as ArrayBufferObject, byteIndexInBuffer, elementType, true, 'unordered');
+}
+
+/** https://tc39.es/ecma262/#sec-integerindexedelementset */
+export function TypedArraySetElement(O: TypedArrayObject, index: NumberValue, value: Value): ExpressionCompletion<BooleanValue> {
+  // 3. If O.[[ContentType]] is BigInt, let numValue be ? ToBigInt(value).
+  // 4. Otherwise, let numValue be ? ToNumber(value).
+  let numValue;
+  if (O.ContentType === 'BigInt') {
+    numValue = Q(ToBigInt(value));
+  } else {
+    numValue = Q(ToNumber(value));
+  }
+  if (IsValidIntegerIndex(O, index) === Value.true) {
+    const offset = O.ByteOffset;
+    const elementSize = TypedArrayElementSize(O);
+    const byteIndexInBuffer = (R(index) * elementSize) + offset;
+    const elementType = TypedArrayElementType(O);
+    SetValueInBuffer(O.ViewedArrayBuffer as ArrayBufferObject, byteIndexInBuffer, elementType, numValue, true, 'unordered');
+    return Value.true;
+  }
+  return Value.true;
+}
+
+/** https://tc39.es/ecma262/#sec-isarraybufferviewoutofbounds */
+export function IsArrayBufferViewOutOfBounds(O: DataViewObject | TypedArrayObject) {
+  if (isDataViewObject(O)) {
+    const viewRecord = MakeDataViewWithBufferWitnessRecord(O, 'seq-cst');
+    return IsViewOutOfBounds(viewRecord);
+  }
+  const taRecord = MakeTypedArrayWithBufferWitnessRecord(O, 'seq-cst');
+  return IsTypedArrayOutOfBounds(taRecord);
+}

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

@@ -0,0 +1,83 @@
+import { surroundingAgent, HostCallJobCallback, type JobCallbackRecord } from '../engine.mts';
+import {
+  BooleanValue, ObjectValue, SymbolValue, UndefinedValue, Value,
+} from '../value.mts';
+import {
+  NormalCompletion, Q, X, type ExpressionCompletion,
+} from '../completion.mts';
+import type { WeakRefObject } from '../intrinsics/WeakRef.mts';
+import type { FinalizationRegistryObject } from '../intrinsics/FinalizationRegistry.mts';
+import { Assert, KeyForSymbol } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-clear-kept-objects */
+export function ClearKeptObjects() {
+  // 1. Let agentRecord be the surrounding agent's Agent Record.
+  const agentRecord = surroundingAgent.AgentRecord;
+  // 2. Set agentRecord.[[KeptAlive]] to a new empty List.
+  agentRecord.KeptAlive = new Set();
+}
+
+/** https://tc39.es/ecma262/#sec-addtokeptobjects */
+export function AddToKeptObjects(object: Value) {
+  // 1. Let agentRecord be the surrounding agent's Agent Record.
+  const agentRecord = surroundingAgent.AgentRecord;
+  // 2. Append object to agentRecord.[[KeptAlive]].
+  agentRecord.KeptAlive.add(object);
+}
+
+/** https://tc39.es/ecma262/#sec-weakrefderef */
+export function WeakRefDeref(weakRef: WeakRefObject) {
+  // 1. Let target be weakRef.[[WeakRefTarget]].
+  const target = weakRef.WeakRefTarget;
+  // 2. If target is not empty, then
+  if (target !== undefined) {
+    // a. Perform ! AddToKeptObjects(target).
+    X(AddToKeptObjects(target));
+    // b. Return target.
+    return target;
+  }
+  // 3. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-cleanup-finalization-registry */
+export function CleanupFinalizationRegistry(finalizationRegistry: FinalizationRegistryObject, callback?: JobCallbackRecord): ExpressionCompletion<UndefinedValue> {
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(finalizationRegistry));
+  // 1. Assert: finalizationRegistry has [[Cells]] and [[CleanupCallback]] internal slots.
+  Assert('Cells' in finalizationRegistry && 'CleanupCallback' in finalizationRegistry);
+  // 2. Set callback to finalizationRegistry.[[CleanupCallback]].
+  if (callback === undefined) {
+    callback = finalizationRegistry.CleanupCallback;
+  }
+  // 3. While finalizationRegistry.[[Cells]] contains a Record cell such that cell.[[WeakRefTarget]] is empty, an implementation may perform the following steps:
+  for (let i = 0; i < finalizationRegistry.Cells.length; i += 1) {
+    // a. Choose any such _cell_.
+    const cell = finalizationRegistry.Cells[i];
+    if (cell.WeakRefTarget !== undefined) {
+      continue;
+    }
+    // b. Remove cell from finalizationRegistry.[[Cells]].
+    finalizationRegistry.Cells.splice(i, 1);
+    i -= 1;
+    // c. Perform ? HostCallJobCallback(callback, undefined, « cell.[[HeldValue]] »).
+    Q(HostCallJobCallback(callback, Value.undefined, [cell.HeldValue]));
+  }
+  // 4. Return NormalCompletion(undefined).
+  return NormalCompletion(Value.undefined);
+}
+
+/** https://tc39.es/ecma262/#sec-canbeheldweakly */
+export function CanBeHeldWeakly(v: Value): BooleanValue {
+  // 1. If v is an Object, return true.
+  if (v instanceof ObjectValue) {
+    return Value.true;
+  }
+
+  // 2. If v is a Symbol and KeyForSymbol(v) is undefined, return true.
+  if (v instanceof SymbolValue && KeyForSymbol(v) === Value.undefined) {
+    return Value.true;
+  }
+
+  // 3. Return false.
+  return Value.false;
+}

package/src/api-types.mts

@@ -0,0 +1,2 @@
+export type { MapObject } from './intrinsics/Map.mts';
+export type { PromiseObject } from './intrinsics/Promise.mts';