@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/abstract-ops/async-generator-objects.mts

@@ -0,0 +1,383 @@
+import { ExecutionContext, surroundingAgent } from '../engine.mts';
+import {
+  Q, X,
+  Await,
+  Completion,
+  EnsureCompletion,
+  NormalCompletion,
+  AbruptCompletion,
+  ThrowCompletion,
+  type ExpressionCompletion,
+  type PlainCompletion,
+  type YieldCompletion,
+} from '../completion.mts';
+import { Evaluate, type YieldEvaluator } from '../evaluator.mts';
+import {
+  BooleanValue, JSStringValue, ObjectValue, UndefinedValue, Value, type Arguments,
+} from '../value.mts';
+import {
+  resume, handleInResume, __ts_cast__, type Mutable,
+} from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Assert,
+  Call,
+  CreateBuiltinFunction,
+  CreateIteratorResultObject,
+  generatorBrandToErrorMessageType,
+  GetGeneratorKind,
+  OrdinaryObjectCreate,
+  PerformPromiseThen,
+  PromiseCapabilityRecord,
+  PromiseResolve,
+  Realm,
+  RequireInternalSlot,
+  SameValue,
+  type OrdinaryObject,
+} from './all.mts';
+
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-asyncgenerator-objects */
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorrequest-records */
+class AsyncGeneratorRequestRecord {
+  Completion: YieldCompletion;
+
+  Capability: PromiseCapabilityRecord;
+
+  constructor(completion: YieldCompletion, promiseCapability: PromiseCapabilityRecord) {
+    this.Completion = completion;
+    this.Capability = promiseCapability;
+  }
+}
+
+export interface AsyncGeneratorObject extends OrdinaryObject {
+  AsyncGeneratorState: 'suspendedStart' | 'suspendedYield' | 'executing' | 'completed' | 'awaiting-return' | UndefinedValue;
+  AsyncGeneratorContext: ExecutionContext;
+  AsyncGeneratorQueue: AsyncGeneratorRequestRecord[];
+  GeneratorBrand: JSStringValue | undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorstart */
+export function AsyncGeneratorStart(generator: AsyncGeneratorObject, generatorBody: ParseNode.AsyncGeneratorBody | (() => YieldEvaluator)) {
+  // 1. Assert: generator.[[AsyncGeneratorState]] is undefined.
+  Assert(generator.AsyncGeneratorState === Value.undefined);
+  __ts_cast__<AsyncGeneratorObject>(generator);
+  // 2. Let genContext be the running execution context.
+  const genContext = surroundingAgent.runningExecutionContext;
+  // 3. Set the Generator component of genContext to generator.
+  genContext.Generator = generator;
+  // 4. Set the code evaluation state of genContext such that when evaluation
+  //    is resumed for that execution context the following steps will be performed:
+  genContext.codeEvaluationState = (function* resumer(): YieldEvaluator {
+    // a. If generatorBody is a Parse Node, then
+    //     i. Let result be the result of evaluating generatorBody.
+    // b. Else,
+    //     i. Assert: generatorBody is an Abstract Closure.
+    //     ii. Let result be generatorBody().
+    let result = EnsureCompletion(
+      // Note: Engine262 can only perform the "If generatorBody is an Abstract Closure" check:
+      yield* typeof generatorBody === 'function'
+        ? generatorBody()
+        : Evaluate(generatorBody),
+    );
+    // c. Assert: If we return here, the async generator either threw an exception or performed either an implicit or explicit return.
+    // d. Remove genContext from the execution context stack and restore the execution context
+    //    that is at the top of the execution context stack as the running execution context.
+    surroundingAgent.executionContextStack.pop(genContext);
+    // e. Set generator.[[AsyncGeneratorState]] to completed.
+    generator.AsyncGeneratorState = 'completed';
+    // f. If result.[[Type]] is normal, set result to NormalCompletion(undefined).
+    if (result.Type === 'normal') {
+      result = NormalCompletion(Value.undefined);
+    }
+    // g. If result.[[Type]] is return, set result to NormalCompletion(result.[[Value]]).
+    if (result.Type === 'return') {
+      result = NormalCompletion(result.Value);
+    }
+    // h. Perform ! AsyncGeneratorCompleteStep(generator, result, true).
+    X(AsyncGeneratorCompleteStep(generator, result as ThrowCompletion, Value.true));
+    // i. Perform ! AsyncGeneratorDrainQueue(generator).
+    X(AsyncGeneratorDrainQueue(generator));
+    // j. Return undefined.
+    return Value.undefined;
+  }());
+  // 5. Set generator.[[AsyncGeneratorContext]] to genContext.
+  generator.AsyncGeneratorContext = genContext;
+  // 6. Set generator.[[AsyncGeneratorState]] to suspendedStart.
+  generator.AsyncGeneratorState = 'suspendedStart';
+  // 7. Set generator.[[AsyncGeneratorQueue]] to a new empty List.
+  generator.AsyncGeneratorQueue = [];
+  // 8. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorvalidate */
+export function AsyncGeneratorValidate(generator: Value, generatorBrand: JSStringValue | undefined) {
+  // 1. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorContext]]).
+  Q(RequireInternalSlot(generator, 'AsyncGeneratorContext'));
+  // 2. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorState]]).
+  Q(RequireInternalSlot(generator, 'AsyncGeneratorState'));
+  // 3. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorQueue]]).
+  Q(RequireInternalSlot(generator, 'AsyncGeneratorQueue'));
+  __ts_cast__<AsyncGeneratorObject>(generator);
+  // 4. If generator.[[GeneratorBrand]] is not the same value as generatorBrand, throw a TypeError exception.
+  const brand = generator.GeneratorBrand;
+  if (
+    brand === undefined || generatorBrand === undefined
+      ? brand !== generatorBrand
+      : SameValue(brand, generatorBrand) === Value.false
+  ) {
+    return surroundingAgent.Throw(
+      'TypeError',
+      'NotATypeObject',
+      generatorBrandToErrorMessageType(generatorBrand) || 'AsyncGenerator',
+      generator,
+    );
+  }
+  return undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorenqueue */
+export function AsyncGeneratorEnqueue(generator: AsyncGeneratorObject, completion: YieldCompletion, promiseCapability: PromiseCapabilityRecord) {
+  // 1. Let request be AsyncGeneratorRequest { [[Completion]]: completion, [[Capability]]: promiseCapability }.
+  const request = new AsyncGeneratorRequestRecord(completion, promiseCapability);
+  // 2. Append request to the end of generator.[[AsyncGeneratorQueue]].
+  generator.AsyncGeneratorQueue.push(request);
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorcompletestep */
+function AsyncGeneratorCompleteStep(generator: AsyncGeneratorObject, completion: YieldCompletion, done: BooleanValue, realm?: Realm) {
+  // 1. Let queue be generator.[[AsyncGeneratorQueue]].
+  const queue = generator.AsyncGeneratorQueue;
+  // 2. Assert: queue is not empty.
+  Assert(queue.length > 0);
+  // 3. Let next be the first element of queue.
+  // 4. Remove the first element from queue.
+  const next = queue.shift()!;
+  // 5. Let promiseCapability be next.[[Capability]].
+  const promiseCapability = next.Capability;
+  // 6. Let value be completion.[[Value]].
+  const value = completion.Value;
+  // 7. If completion.[[Type]] is throw, then
+  if (completion.Type === 'throw') {
+    // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « value »).
+    X(Call(promiseCapability.Reject, Value.undefined, [value!]));
+  } else { // 8. Else,
+    // a. Assert: completion.[[Type]] is normal.
+    Assert(completion.Type === 'normal');
+    let iteratorResult;
+    // b. If realm is present, then
+    if (realm !== undefined) {
+      // i. Let oldRealm be the running execution context's Realm.
+      const oldRealm = surroundingAgent.runningExecutionContext.Realm;
+      // ii. Set the running execution context's Realm to realm.
+      surroundingAgent.runningExecutionContext.Realm = realm;
+      // iii. Let iteratorResult be ! CreateIteratorResultObject(value, done).
+      iteratorResult = X(CreateIteratorResultObject(value!, done));
+      // iv. Set the running execution context's Realm to oldRealm.
+      surroundingAgent.runningExecutionContext.Realm = oldRealm;
+    } else { // c. Else,
+      // i. Let iteratorResult be ! CreateIteratorResultObject(value, done).
+      iteratorResult = X(CreateIteratorResultObject(value!, done));
+    }
+    // d. Perform ! Call(promiseCapability.[[Resolve]], undefined, « iteratorResult »).
+    X(Call(promiseCapability.Resolve, Value.undefined, [iteratorResult]));
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorresume */
+export function AsyncGeneratorResume(generator: AsyncGeneratorObject, completion: YieldCompletion) {
+  // 1. Assert: generator.[[AsyncGeneratorState]] is either suspendedStart or suspendedYield.
+  Assert(generator.AsyncGeneratorState === 'suspendedStart' || generator.AsyncGeneratorState === 'suspendedYield');
+  // 2. Let genContext be generator.[[AsyncGeneratorContext]].
+  const genContext = generator.AsyncGeneratorContext;
+  // 3. Let callerContext be the running execution context.
+  const callerContext = surroundingAgent.runningExecutionContext;
+  // 4. Suspend callerContext.
+  // 5. Set generator.[[AsyncGeneratorState]] to executing.
+  generator.AsyncGeneratorState = 'executing';
+  // 6. Push genContext onto the execution context stack; genContext is now the running execution context.
+  surroundingAgent.executionContextStack.push(genContext);
+  // 7. Resume the suspended evaluation of genContext using completion as the result of the operation that suspended it. Let result be the completion record returned by the resumed computation.
+  const result = resume(genContext, completion);
+  // 8. Assert: result is never an abrupt completion.
+  Assert(!(result instanceof AbruptCompletion));
+  // 9. Assert: When we return here, genContext has already been removed from the execution context stack and callerContext is the currently running execution context.
+  Assert(surroundingAgent.runningExecutionContext === callerContext);
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorunwrapyieldresumption */
+function* AsyncGeneratorUnwrapYieldResumption(resumptionValue: YieldCompletion): YieldEvaluator {
+  // 1. If resumptionValue.[[Type]] is not return, return Completion(resumptionValue).
+  if (resumptionValue.Type !== 'return') {
+    return Completion(resumptionValue) as ExpressionCompletion;
+  }
+  // 2. Let awaited be Await(resumptionValue.[[Value]]).
+  const awaited = EnsureCompletion(yield* Await(resumptionValue.Value));
+  // 3. If awaited.[[Type]] is throw, return Completion(awaited).
+  if (awaited.Type === 'throw') {
+    return Completion(awaited);
+  }
+  // 4. Assert: awaited.[[Type]] is normal.
+  Assert(awaited.Type === 'normal');
+  // 5. Return Completion { [[Type]]: return, [[Value]]: awaited.[[Value]], [[Target]]: empty }.
+  return new Completion({ Type: 'return', Value: awaited.Value, Target: undefined });
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratoryield */
+export function* AsyncGeneratorYield(value: Value): YieldEvaluator {
+  // 1. Let genContext be the running execution context.
+  const genContext = surroundingAgent.runningExecutionContext;
+  // 2. Assert: genContext is the execution context of a generator.
+  Assert(!!genContext.Generator);
+  // 3. Let generator be the value of the Generator component of genContext.
+  const generator = genContext.Generator as AsyncGeneratorObject;
+  // 4. Assert: GetGeneratorKind() is async.
+  Assert(GetGeneratorKind() === 'async');
+  // 5. Let completion be NormalCompletion(value).
+  const completion = NormalCompletion(value);
+  // 6. Assert: The execution context stack has at least two elements.
+  Assert(surroundingAgent.executionContextStack.length >= 2);
+  // 7. Let previousContext be the second to top element of the execution context stack.
+  const previousContext = surroundingAgent.executionContextStack[surroundingAgent.executionContextStack.length - 2];
+  // 8. Let previousRealm be previousContext's Realm.
+  const previousRealm = previousContext.Realm;
+  // 9. Perform ! AsyncGeneratorCompleteStep(generator, completion, false, previousRealm).
+  X(AsyncGeneratorCompleteStep(generator, completion, Value.false, previousRealm));
+  // 10. Let queue be generator.[[AsyncGeneratorQueue]].
+  const queue = generator.AsyncGeneratorQueue;
+  // 11. If queue is not empty, then
+  if (queue.length > 0) {
+    // a. NOTE: Execution continues without suspending the generator.
+    // b. Let toYield be the first element of queue.
+    const toYield = queue[0];
+    // c. Let resumptionValue be toYield.[[Completion]].
+    const resumptionValue = toYield.Completion;
+    // d. Return AsyncGeneratorUnwrapYieldResumption(resumptionValue).
+    return yield* AsyncGeneratorUnwrapYieldResumption(resumptionValue);
+  } else { // 12. Else,
+    // a. Set generator.[[AsyncGeneratorState]] to suspendedYield.
+    generator.AsyncGeneratorState = 'suspendedYield';
+    // b. Remove genContext from the execution context stack and restore the execution context that is at the top of the execution context stack as the running execution context.
+    surroundingAgent.executionContextStack.pop(genContext);
+    // c. Set the code evaluation state of genContext such that when evaluation is resumed with a Completion resumptionValue the following steps will be performed:
+    // TODO: figure out this type
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const resumptionValue = EnsureCompletion(yield handleInResume(() => Value.undefined) as any);
+    // i. Return AsyncGeneratorUnwrapYieldResumption(resumptionValue).
+    return yield* AsyncGeneratorUnwrapYieldResumption(resumptionValue);
+    // ii. NOTE: When the above step returns, it returns to the evaluation of the YieldExpression production that originally called this abstract operation.
+
+    // d. Return undefined.
+    // e. NOTE: This returns to the evaluation of the operation that had most previously resumed evaluation of genContext.
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratorawaitreturn */
+export function AsyncGeneratorAwaitReturn(generator: AsyncGeneratorObject): PlainCompletion<void> {
+  // 1. Let queue be generator.[[AsyncGeneratorQueue]].
+  const queue = generator.AsyncGeneratorQueue;
+  // 2. Assert: queue is not empty.
+  Assert(queue.length > 0);
+  // 3. Let next be the first element of queue.
+  const next = queue[0];
+  // 4. Let completion be next.[[Completion]].
+  const completion = next.Completion;
+  // 5. Assert: completion.[[Type]] is return.
+  Assert(completion.Type === 'return');
+  // 6. Let promise be ? PromiseResolve(%Promise%, completion.[[Value]]).
+  const promise = Q(PromiseResolve(surroundingAgent.intrinsic('%Promise%'), completion.Value));
+  // 7. Let fulfilledClosure be a new Abstract Closure with parameters (value) that captures generator and performs the following steps when called:
+  const fulfilledClosure = ([value = Value.undefined]: Arguments) => {
+    // a. Set generator.[[AsyncGeneratorState]] to completed.
+    generator.AsyncGeneratorState = 'completed';
+    // b. Let result be NormalCompletion(value).
+    const result = NormalCompletion(value);
+    // c. Perform ! AsyncGeneratorCompleteStep(generator, result, true).
+    X(AsyncGeneratorCompleteStep(generator, result, Value.true));
+    // d. Perform ! AsyncGeneratorDrainQueue(generator).
+    X(AsyncGeneratorDrainQueue(generator));
+    // e. Return undefined.
+    return Value.undefined;
+  };
+  // 8. Let onFulfilled be ! CreateBuiltinFunction(fulfilledClosure, 1, "", « »).
+  const onFulfilled = X(CreateBuiltinFunction(fulfilledClosure, 1, Value(''), []));
+  // 9. Let rejectedClosure be a new Abstract Closure with parameters (reason) that captures generator and performs the following steps when called:
+  const rejectedClosure = ([reason = Value.undefined]: Arguments) => {
+    // a. Set generator.[[AsyncGeneratorState]] to completed.
+    generator.AsyncGeneratorState = 'completed';
+    // b. Let result be ThrowCompletion(reason).
+    const result = ThrowCompletion(reason);
+    // c. Perform ! AsyncGeneratorCompleteStep(generator, result, true).
+    X(AsyncGeneratorCompleteStep(generator, result, Value.true));
+    // d. Perform ! AsyncGeneratorDrainQueue(generator).
+    X(AsyncGeneratorDrainQueue(generator));
+    // e. Return undefined.
+    return Value.undefined;
+  };
+  // 10. Let onRejected be ! CreateBuiltinFunction(rejectedClosure, 1, "", « »).
+  const onRejected = X(CreateBuiltinFunction(rejectedClosure, 1, Value(''), []));
+  // 11. Perform ! PerformPromiseThen(promise, onFulfilled, onRejected).
+  X(PerformPromiseThen(promise, onFulfilled, onRejected));
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgeneratordrainqueue */
+function AsyncGeneratorDrainQueue(generator: AsyncGeneratorObject) {
+  // 1. Assert: generator.[[AsyncGeneratorState]] is completed.
+  Assert(generator.AsyncGeneratorState === 'completed');
+  // 2. Let queue be generator.[[AsyncGeneratorQueue]].
+  const queue = generator.AsyncGeneratorQueue;
+  // 3. If queue is empty, return.
+  if (queue.length === 0) {
+    return;
+  }
+  // 4. Let done be false.
+  let done = false;
+  // 5. Repeat, while done is false,
+  while (done === false) {
+    // a. Let next be the first element of queue.
+    const next = queue[0];
+    // b. Let completion be next.[[Completion]].
+    let completion = next.Completion;
+    // c. If completion.[[Type]] is return, then
+    if (completion.Type === 'return') {
+      // i. Set generator.[[AsyncGeneratorState]] to awaiting-return.
+      generator.AsyncGeneratorState = 'awaiting-return';
+      // ii. Perform ! AsyncGeneratorAwaitReturn(generator).
+      X(AsyncGeneratorAwaitReturn(generator));
+      // iii. Set done to true.
+      done = true;
+    } else { // d. Else,
+      // i. If completion.[[Type]] is normal, then
+      if (completion.Type === 'normal') {
+        // 1. Set completion to NormalCompletion(undefined).
+        completion = NormalCompletion(Value.undefined);
+      }
+      // ii. Perform ! AsyncGeneratorCompleteStep(generator, completion, true).
+      X(AsyncGeneratorCompleteStep(generator, completion, Value.true));
+      // iii. If queue is empty, set done to true.
+      if (queue.length === 0) {
+        done = true;
+      }
+    }
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-createasynciteratorfromclosure */
+export function CreateAsyncIteratorFromClosure(closure: () => YieldEvaluator, generatorBrand: JSStringValue, generatorPrototype: ObjectValue) {
+  Assert(typeof closure === 'function');
+  // 1. NOTE: closure can contain uses of the Await shorthand, and uses of the Yield shorthand to yield an IteratorResult object.
+  // 2. Let internalSlotsList be « [[AsyncGeneratorState]], [[AsyncGeneratorContext]], [[AsyncGeneratorQueue]], [[GeneratorBrand]] ».
+  const internalSlotsList = ['AsyncGeneratorState', 'AsyncGeneratorContext', 'AsyncGeneratorQueue', 'GeneratorBrand'];
+  // 3. Let generator be ! OrdinaryObjectCreate(generatorPrototype, internalSlotsList).
+  const generator = X(OrdinaryObjectCreate(generatorPrototype, internalSlotsList)) as Mutable<AsyncGeneratorObject>;
+  // 4. Set generator.[[GeneratorBrand]] to generatorBrand.
+  generator.GeneratorBrand = generatorBrand;
+  // 5. Set generator.[[AsyncGeneratorState]] to undefined.
+  generator.AsyncGeneratorState = Value.undefined;
+  // 6. Perform ? AsyncGeneratorStart(generator, closure, generatorBrand).
+  Q(AsyncGeneratorStart(generator, closure));
+  // 7. Return generator.
+  return generator;
+}

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,151 @@
+import { Q } from '../completion.mts';
+import { surroundingAgent } from '../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) === Value.true) {
+    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;
+  Assert(
+    (IsDetachedBuffer(view.ViewedArrayBuffer as ArrayBufferObject) === Value.true && bufferByteLength === 'detached')
+    || (IsDetachedBuffer(view.ViewedArrayBuffer as ArrayBufferObject) === Value.false && bufferByteLength !== 'detached'),
+  );
+  if (bufferByteLength === 'detached') {
+    return true;
+  }
+  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(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(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(ToBigInt(value));
+  } else {
+    numberValue = Q(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).
+  SetValueInBuffer(view.ViewedArrayBuffer as ArrayBufferObject, bufferIndex, type, numberValue, Value.false, 'unordered', isLittleEndian);
+  return Value.undefined;
+}