@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/host-defined/test262-intrinsics.mts

@@ -0,0 +1,167 @@
+/* eslint-disable no-console */
+// defined intrinsics that used in test262
+import { isArray } from '../utils/language.mts';
+import harness from '../../lib/test262-harness.json' with { type: 'json' };
+import {
+  CreateBuiltinFunction, DetachArrayBuffer, EnsureCompletion, inspect, isArrayBufferObject, isBuiltinFunctionObject, JSStringValue, ManagedRealm, NormalCompletion, OrdinaryObjectCreate, Q, surroundingAgent, ToString, Value, type Arguments, gc,
+  ParseScript,
+  ThrowCompletion,
+  Throw,
+  ScriptEvaluation,
+  CreateNonEnumerableDataPropertyOrThrow,
+  type ValueEvaluator,
+  X,
+  type NativeSteps,
+  Call,
+  Assert,
+  HasProperty,
+  Set,
+} from '#self';
+
+/** https://github.com/tc39/test262/blob/main/INTERPRETING.md */
+export function createTest262Intrinsics(realm: ManagedRealm, printCompatMode: boolean, log: (...args: unknown[]) => void = Reflect.get(globalThis, 'console').log) {
+  const pop = realm.pushTopContext();
+  const print = CreateBuiltinFunction(function* print(args: Arguments): ValueEvaluator {
+    if (surroundingAgent.debugger_isPreviewing) {
+      return NormalCompletion(Value.undefined);
+    }
+    /* node:coverage ignore next */
+    if (printCompatMode) {
+      const str: string[] = [];
+      for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i]!;
+        const s = EnsureCompletion(yield* ToString(arg));
+        if (s.Type === 'throw') {
+          return s;
+        }
+        str.push(s.Value.stringValue());
+      }
+      log(...str);
+      return Value.undefined;
+    } else {
+      const formatted = args.map((a, i) => {
+        if (i === 0 && a instanceof JSStringValue) {
+          return a.stringValue();
+        }
+        return inspect(a);
+      }).join(' ');
+      log(formatted);
+    }
+    return Value.undefined;
+  }, 0, Value('print'), []);
+  CreateNonEnumerableDataPropertyOrThrow(realm.GlobalObject, Value('print'), print);
+
+  const $262 = OrdinaryObjectCreate.from({
+    AbstractModuleSource: realm.Intrinsics['%AbstractModuleSource%'],
+    createRealm: function* createRealm(): ValueEvaluator {
+      Q(surroundingAgent.debugger_cannotPreview);
+      const realm = new ManagedRealm();
+      const { $262 } = createTest262Intrinsics(realm, printCompatMode, log);
+      return $262;
+    },
+    detachArrayBuffer: function* detachArrayBuffer(arrayBuffer = Value.undefined) {
+      if (!isArrayBufferObject(arrayBuffer)) {
+        return Throw.TypeError('argument[0] must be an ArrayBuffer');
+      }
+      Q(DetachArrayBuffer(arrayBuffer));
+      return Value.undefined;
+    },
+    evalScript: function* evalScript(sourceText) {
+      if (!(sourceText instanceof JSStringValue)) {
+        return Throw.TypeError('argument[0] must be a string');
+      }
+      const s = ParseScript(sourceText.stringValue(), surroundingAgent.currentRealmRecord);
+      if (isArray(s)) {
+        return ThrowCompletion(s[0]);
+      }
+      const status = yield* ScriptEvaluation(s);
+      return status;
+    },
+    gc,
+    global: realm.GlobalObject,
+    // TODO: agent only if we have multi-threading.
+
+    // engine262 only
+    spec: function* spec(value) {
+      if (isBuiltinFunctionObject(value) && value.nativeFunction.section) {
+        return Value(value.nativeFunction.section);
+      }
+      return Value.undefined;
+    },
+    debugger: function* hostDebugger(value = Value.undefined, callValue = Value.false): ValueEvaluator {
+      if (surroundingAgent.debugger_isPreviewing) {
+        return Value.undefined;
+      }
+      // eslint-disable-next-line no-debugger
+      debugger;
+      if (callValue !== Value.false) {
+        Q(yield* Call(value, Value.undefined, []));
+      }
+      return Value.undefined;
+    },
+  });
+  // engine262 only
+  CreateNonEnumerableDataPropertyOrThrow(realm.GlobalObject, Value('$262'), $262);
+  CreateNonEnumerableDataPropertyOrThrow(realm.GlobalObject, Value('$'), $262);
+  pop?.();
+
+  return {
+    $262,
+  };
+}
+
+export function importBundledTest262Harness(
+  realm: ManagedRealm,
+  nameMapper = (str: string) => `https://github.com/tc39/test262/blob/main/harness/${str}`,
+) {
+  for (const [specifier, file] of Object.entries(harness)) {
+    if (specifier.includes('atomicsHelper.js')) continue;
+    const completion = realm.evaluateScriptSkipDebugger(file, { specifier: nameMapper(specifier) });
+    if (completion instanceof ThrowCompletion) {
+      throw completion;
+    }
+  }
+}
+
+export function boostTest262Harness(realm: ManagedRealm) {
+  // test262/harness/regExpUtils.js
+  const key = Value('buildString');
+  const pop = realm.pushTopContext();
+  if (X(HasProperty(realm.GlobalObject, key)) === Value.true) {
+    X(Set(realm.GlobalObject, key, CreateBuiltinFunction(boostHarness.buildString, 1, key, []), Value.true));
+  }
+  pop?.();
+}
+
+const boostHarness = {
+  * buildString(argumentsList): ValueEvaluator {
+    const json = Q(yield* Call(surroundingAgent.intrinsic('%JSON.stringify%'), Value.null, [argumentsList[0] || Value.undefined]));
+    Assert(json instanceof JSStringValue);
+    const jsonString = json.stringValue();
+
+    const { loneCodePoints, ranges } = JSON.parse(jsonString);
+
+    // #region test262/harness/regExpUtils.js
+    const CHUNK_SIZE = 10000;
+    let result = String.fromCodePoint.apply(null, loneCodePoints);
+    for (let i = 0; i < ranges.length; i += 1) {
+      const range = ranges[i];
+      const start = range[0];
+      const end = range[1];
+      const codePoints: number[] = [];
+      for (let length = 0, codePoint = start; codePoint <= end; codePoint += 1) {
+        codePoints[length] = codePoint;
+        length += 1;
+        if (length === CHUNK_SIZE) {
+          result += String.fromCodePoint.apply(null, codePoints);
+          length = 0;
+          codePoints.length = 0;
+        }
+      }
+      result += String.fromCodePoint.apply(null, codePoints);
+    }
+    // #endregion
+
+    return Value(result);
+  },
+} satisfies Record<string, NativeSteps>;

package/src/index.mts

@@ -0,0 +1,66 @@
+export * from './abstract-ops/all.mts';
+export * from './execution-context/all.mts';
+export * from './static-semantics/all.mts';
+export * from './runtime-semantics/all.mts';
+export * from './value.mts';
+export * from './host-defined/engine.mts';
+export { runSingleJobInQueue, type JobQueue, BasicJobQueue } from './host-defined/job-queue.mts';
+export {
+  type EventLoop, type EventLoopRunType, type NodeJSJobType, AbstractEventLoop, MicroTaskEventLoop, WebLikeEventLoop, NodeJSLikeEventLoop,
+} from './host-defined/event-loop.mts';
+export * from './completion.mts';
+export * from './parse.mts';
+export * from './modules.mts';
+export * from './host-defined/inspect.mts';
+export { performDevtoolsEval } from './host-defined/devtoolsEval.mts';
+export { type Formattable, Throw } from './host-defined/error-messages.mts';
+export * from './evaluator.mts';
+
+export {
+  gc, type ManagedRealmHostDefined, ManagedRealm,
+} from './api.mts';
+export type { ParseNode } from './parser/ParseNode.mts';
+export { createTest262Intrinsics, boostTest262Harness, importBundledTest262Harness } from './host-defined/test262-intrinsics.mts';
+export { type Mutable, OutOfRange } from './utils/language.mts';
+export { kInternal } from './utils/internal.mts';
+export { JSStringMap, JSStringSet, PropertyKeyMap } from './utils/container.mts';
+export {
+  CallSite, CallFrame, captureStack, getHostDefinedErrorDetails, getCurrentStack,
+} from './utils/stack.mts';
+export { ModuleCache, type ModuleCacheKey, type ModuleCacheLoader } from './utils/module.mts';
+export {
+  type ModuleLoader, type ModuleLoaderResultWithCacheKey, type ModuleLoaderResultWithoutCacheKey, composeModuleLoaders,
+} from './utils/module-loader.mts';
+export { createBuiltinModuleLoader, type BuiltinModuleSource, type BuiltinModuleLoaderOptions } from './utils/module-loaders/builtin-loader.mts';
+
+export { ThisBigIntValue } from './intrinsics/BigIntPrototype.mts';
+export { ThisBooleanValue } from './intrinsics/BooleanPrototype.mts';
+export { ThisNumberValue } from './intrinsics/NumberPrototype.mts';
+export { ThisStringValue } from './intrinsics/StringPrototype.mts';
+export { ThisSymbolValue } from './intrinsics/SymbolPrototype.mts';
+export { isBoundFunctionObject, type BoundFunctionObject } from './intrinsics/FunctionPrototype.mts';
+export { isMapObject, type MapObject } from './intrinsics/Map.mts';
+export { isSetObject, type SetObject } from './intrinsics/Set.mts';
+export { isRegExpObject, type RegExpObject } from './intrinsics/RegExp.mts';
+export { isWeakMapObject, type WeakMapObject } from './intrinsics/WeakMap.mts';
+export { isWeakSetObject, type WeakSetObject } from './intrinsics/WeakSet.mts';
+export { isDataViewObject, type DataViewObject } from './intrinsics/DataView.mts';
+export { isDateObject, type DateObject } from './intrinsics/Date.mts';
+export { DateProto_toISOString } from './intrinsics/DatePrototype.mts';
+export { isPromiseObject, SafePerformPromiseAll, type PromiseObject } from './intrinsics/Promise.mts';
+export { isTypedArrayObject, type TypedArrayObject } from './intrinsics/TypedArray.mts';
+export { isProxyExoticObject, type ProxyObject } from './intrinsics/Proxy.mts';
+export { isWeakRef, type WeakRefObject } from './intrinsics/WeakRef.mts';
+export { isFinalizationRegistryObject, type FinalizationRegistryObject } from './intrinsics/FinalizationRegistry.mts';
+export { isErrorObject, type ErrorObject } from './intrinsics/Error.mts';
+export { isShadowRealmObject, type ShadowRealmObject } from './intrinsics/ShadowRealm.mts';
+export { type ModuleSourceObject } from './intrinsics/AbstractModuleSource.mts';
+
+export { isTemporalDurationObject, type TemporalDurationObject } from './intrinsics/Temporal/Duration.mts';
+export { isTemporalInstantObject, type TemporalInstantObject } from './intrinsics/Temporal/Instant.mts';
+export { isTemporalPlainDateObject, type TemporalPlainDateObject } from './intrinsics/Temporal/PlainDate.mts';
+export { isTemporalPlainDateTimeObject, type TemporalPlainDateTimeObject } from './intrinsics/Temporal/PlainDateTime.mts';
+export { isTemporalPlainMonthDayObject, type TemporalPlainMonthDayObject } from './intrinsics/Temporal/PlainMonthDay.mts';
+export { isTemporalPlainTimeObject, type TemporalPlainTimeObject } from './intrinsics/Temporal/PlainTime.mts';
+export { isTemporalPlainYearMonthObject, type TemporalPlainYearMonthObject } from './intrinsics/Temporal/PlainYearMonth.mts';
+export { isTemporalZonedDateTimeObject, type TemporalZonedDateTimeObject } from './intrinsics/Temporal/ZonedDateTime.mts';

package/src/intrinsics/AbstractModuleSource.mts

@@ -0,0 +1,47 @@
+import {
+  ObjectValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { bootstrapConstructor, bootstrapPrototype } from './bootstrap.mts';
+import {
+  Assert,
+  HostGetModuleSourceModuleRecord,
+  Realm,
+  Throw,
+} from '#self';
+
+export type ModuleSourceObject = ObjectValue;
+
+/** https://tc39.es/proposal-source-phase-imports/#sec-abstractmodulesource */
+function AbstractModuleSourceConstructor(_args: Arguments, _context: FunctionCallContext) {
+  // 1. Throw a TypeError exception.
+  return Throw.TypeError('AbstractModuleSource cannot be constructed');
+}
+
+/** https://tc39.es/proposal-source-phase-imports/#sec-get-%abstractmodulesource%.prototype-%symbol.tostringtag% */
+function AbstractModuleSourceProto_toStringTagGetter(_args: Arguments, { thisValue }: FunctionCallContext) {
+  const O = thisValue;
+  if (!(O instanceof ObjectValue)) {
+    return Value.undefined;
+  }
+  const module = HostGetModuleSourceModuleRecord(O);
+  if (module === 'not-a-source') {
+    return Value.undefined;
+  }
+  const name = module.GetModuleSourceKind();
+  Assert(typeof name === 'string');
+  return Value(name);
+}
+
+export function bootstrapAbstractModuleSource(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    [wellKnownSymbols.toStringTag, [AbstractModuleSourceProto_toStringTagGetter, Value.undefined]],
+  ], realmRec.Intrinsics['%Object.prototype%']);
+  const constructor = bootstrapConstructor(realmRec, AbstractModuleSourceConstructor, 'AbstractModuleSource', 0, proto);
+  constructor.Prototype = realmRec.Intrinsics['%Function.prototype%'];
+  realmRec.Intrinsics['%AbstractModuleSource.prototype%'] = proto;
+  realmRec.Intrinsics['%AbstractModuleSource%'] = constructor;
+}

package/src/intrinsics/AggregateError.mts

@@ -0,0 +1,66 @@
+import {
+  Value, Descriptor, type Arguments, type FunctionCallContext,
+  UndefinedValue,
+} from '../value.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { captureStack } from '../utils/stack.mts';
+import { setErrorHostInternalSlot } from './Error.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { ErrorHostInternalSlots, type ErrorObject } from './Error.mts';
+import { surroundingAgent } from '#self';
+import {
+  ToString,
+  IteratorToList,
+  OrdinaryCreateFromConstructor,
+  DefinePropertyOrThrow,
+  InstallErrorCause,
+  CreateArrayFromList,
+  type FunctionObject,
+  CreateNonEnumerableDataPropertyOrThrow,
+  GetIterator,
+  Realm,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-aggregate-error-constructor */
+function* AggregateErrorConstructor([errors = Value.undefined, message = Value.undefined, options = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  // 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 as FunctionObject;
+  } else {
+    newTarget = NewTarget;
+  }
+  // 2. Let O be ? OrdinaryCreateFromConstructor(newTarget, "%AggregateError.prototype%", « [[ErrorData]] »).
+  const O = Q(yield* OrdinaryCreateFromConstructor(newTarget, '%AggregateError.prototype%', [
+    'ErrorData',
+    ...ErrorHostInternalSlots,
+  ])) as ErrorObject;
+  // 3. If message is not undefined, then
+  if (message !== Value.undefined) {
+    // a. Let msg be ? ToString(message).
+    const msg = Q(yield* ToString(message));
+    // b. Perform ! CreateMethodProperty(O, "message", msg).
+    X(CreateNonEnumerableDataPropertyOrThrow(O, Value('message'), msg));
+  }
+  Q(yield* InstallErrorCause(O, options));
+  // 4. Let errorsList be ? IterableToList(errors).
+  const errorsList = Q(yield* IteratorToList(Q(yield* GetIterator(errors, 'sync'))));
+  // 5. Perform ! DefinePropertyOrThrow(O, "errors", Property Descriptor { [[Configurable]]: true, [[Enumerable]]: false, [[Writable]]: true, [[Value]]: ! CreateArrayFromList(errorsList) }).
+  X(DefinePropertyOrThrow(O, Value('errors'), Descriptor({
+    Configurable: Value.true,
+    Enumerable: Value.false,
+    Writable: Value.true,
+    Value: CreateArrayFromList(errorsList),
+  })));
+
+  Q(yield* setErrorHostInternalSlot(O, captureStack()));
+
+  // 7. Return O.
+  return O;
+}
+
+export function bootstrapAggregateError(realmRec: Realm) {
+  const c = bootstrapConstructor(realmRec, AggregateErrorConstructor, 'AggregateError', 2, realmRec.Intrinsics['%AggregateError.prototype%'], []);
+  c.Prototype = realmRec.Intrinsics['%Error%'];
+  realmRec.Intrinsics['%AggregateError%'] = c;
+}

package/src/intrinsics/AggregateErrorPrototype.mts

@@ -0,0 +1,12 @@
+import { Value } from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { Realm } from '#self';
+
+export function bootstrapAggregateErrorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['name', Value('AggregateError')],
+    ['message', Value('')],
+  ], realmRec.Intrinsics['%Error.prototype%'], 'AggregateError');
+
+  realmRec.Intrinsics['%AggregateError.prototype%'] = proto;
+}

package/src/intrinsics/Array.mts

@@ -0,0 +1,302 @@
+import {
+  Await,
+  IfAbruptCloseIterator,
+  Q,
+  ThrowCompletion, X,
+  type ValueCompletion,
+  type ValueEvaluator,
+} from '../completion.mts';
+import {
+  NumberValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { __ts_cast__ } from '../utils/language.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import {
+  surroundingAgent,
+  Realm,
+  IfAbruptCloseAsyncIterator, IteratorValue, Throw,
+} from '#self';
+import {
+  ArrayCreate,
+  Assert,
+  Call,
+  Construct,
+  CreateDataPropertyOrThrow,
+  Get,
+  GetMethod,
+  GetPrototypeFromConstructor,
+  IsArray,
+  IsCallable,
+  IsConstructor,
+  IteratorClose,
+  Set,
+  LengthOfArrayLike,
+  ToObject,
+  ToString,
+  ToUint32,
+  F, R,
+  type FunctionObject,
+  IteratorStepValue,
+  GetIteratorFromMethod,
+  type IteratorRecord,
+  CreateAsyncFromSyncIterator,
+  AsyncIteratorClose,
+  IteratorComplete,
+  SameValueZero,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-array-constructor */
+function* ArrayConstructor(values: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  const newTarget = NewTarget instanceof UndefinedValue ? surroundingAgent.activeFunctionObject as FunctionObject : NewTarget;
+  const proto = Q(yield* GetPrototypeFromConstructor(newTarget, '%Array.prototype%'));
+  const numberOfArgs = values.length;
+  if (numberOfArgs === 0) return X(ArrayCreate(0, proto));
+  else if (numberOfArgs === 1) {
+    const len = values[0]!;
+    const array = X(ArrayCreate(0, proto));
+    let intLen;
+    if (!(len instanceof NumberValue)) {
+      X(CreateDataPropertyOrThrow(array, Value('0'), len));
+      intLen = F(1);
+    } else {
+      intLen = X(ToUint32(len));
+      if (!SameValueZero(intLen, len)) {
+        return Throw.RangeError('$1 is not a valid array length', len);
+      }
+    }
+    X(yield* Set(array, Value('length'), intLen, Value.true));
+    return array;
+  }
+
+  const array = Q(ArrayCreate(numberOfArgs, proto));
+  let k = 0;
+  while (k < numberOfArgs) {
+    const Pk = X(ToString(F(k)));
+    const itemK = values[k]!;
+    X(CreateDataPropertyOrThrow(array, Pk, itemK));
+    k += 1;
+  }
+  Assert(R(X(Get(array, Value('length'))) as NumberValue) === numberOfArgs);
+  return array;
+}
+
+/** https://tc39.es/ecma262/#sec-array.from */
+function* Array_from([items = Value.undefined, mapper = Value.undefined, thisArg = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  const constructor = thisValue;
+  let mapping;
+  let array;
+  if (mapper === Value.undefined) {
+    mapping = false;
+  } else {
+    if (!IsCallable(mapper)) {
+      return Throw.TypeError('$1 is not a function', mapper);
+    }
+    mapping = true;
+  }
+  const usingIterator = Q(yield* GetMethod(items, wellKnownSymbols.iterator));
+  if (!(usingIterator instanceof UndefinedValue)) {
+    if (IsConstructor(constructor)) {
+      array = Q(yield* Construct(constructor));
+    } else {
+      array = X(ArrayCreate(0));
+    }
+    const iteratorRecord = Q(yield* GetIteratorFromMethod(items, usingIterator));
+    let k = 0;
+    while (true) { // eslint-disable-line no-constant-condition
+      if (k >= (2 ** 53) - 1) {
+        const error = ThrowCompletion(Throw.TypeError('Cannot make length of array-like object surpass the bounds of an integer index').Value);
+        return Q(yield* IteratorClose(iteratorRecord, error));
+      }
+      const Pk = X(ToString(F(k)));
+      const next = Q(yield* IteratorStepValue(iteratorRecord));
+      if (next === 'done') {
+        Q(yield* Set(array, Value('length'), F(k), Value.true));
+        return array;
+      }
+      let mappedValue;
+      if (mapping) {
+        mappedValue = yield* Call(mapper, thisArg, [next, F(k)]);
+        IfAbruptCloseIterator(mappedValue, iteratorRecord);
+        __ts_cast__<Value>(mappedValue);
+      } else {
+        mappedValue = next;
+      }
+      const defineStatus = yield* CreateDataPropertyOrThrow(array, Pk, mappedValue);
+      IfAbruptCloseIterator(defineStatus, iteratorRecord);
+      k += 1;
+    }
+  }
+  const arrayLike = X(ToObject(items));
+  const len = Q(yield* LengthOfArrayLike(arrayLike));
+  if (IsConstructor(constructor)) {
+    array = Q(yield* Construct(constructor, [F(len)]));
+  } else {
+    array = Q(ArrayCreate(len));
+  }
+  let k = 0;
+  while (k < len) {
+    const Pk = X(ToString(F(k)));
+    const kValue = Q(yield* Get(arrayLike, Pk));
+    let mappedValue;
+    if (mapping === true) {
+      mappedValue = Q(yield* Call(mapper, thisArg, [kValue, F(k)]));
+    } else {
+      mappedValue = kValue;
+    }
+    Q(yield* CreateDataPropertyOrThrow(array, Pk, mappedValue));
+    k += 1;
+  }
+  Q(yield* Set(array, Value('length'), F(len), Value.true));
+  return array;
+}
+
+/** https://tc39.es/ecma262/#sec-array.fromasync */
+function* Array_fromAsync([items = Value.undefined, mapper = Value.undefined, thisArg = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  const constructor = thisValue;
+  let mapping = false;
+  if (mapper !== Value.undefined) {
+    if (!IsCallable(mapper)) {
+      return Throw.TypeError('arguments[1] ($1) is not a function', mapper);
+    }
+    mapping = true;
+  }
+  let iteratorRecord: IteratorRecord | undefined;
+  const usingAsyncIterator = Q(yield* GetMethod(items, wellKnownSymbols.asyncIterator));
+  let usingSyncIterator: UndefinedValue | FunctionObject = Value.undefined;
+  if (usingAsyncIterator instanceof UndefinedValue) {
+    usingSyncIterator = Q(yield* GetMethod(items, wellKnownSymbols.iterator));
+    if (!(usingSyncIterator instanceof UndefinedValue)) {
+      iteratorRecord = CreateAsyncFromSyncIterator(Q(yield* GetIteratorFromMethod(items, usingSyncIterator)));
+    }
+  } else {
+    iteratorRecord = Q(yield* GetIteratorFromMethod(items, usingAsyncIterator));
+  }
+
+  if (iteratorRecord) {
+    const MAX_SAFE_INTEGER = (2 ** 53) - 1;
+    let array: ObjectValue;
+    if (IsConstructor(constructor)) {
+      array = Q(yield* Construct(constructor));
+    } else {
+      array = X(ArrayCreate(0));
+    }
+
+    let k = 0;
+    while (true) {
+      if (k > MAX_SAFE_INTEGER) {
+        const error = Throw.TypeError('Iterator length is bigger than MAX_SAFE_INTEGER');
+        return Q(yield* AsyncIteratorClose(iteratorRecord, error));
+      }
+
+      const Pk = X(ToString(F(k)));
+      let nextResult: Value = Q(yield* Call(iteratorRecord.NextMethod, iteratorRecord.Iterator));
+      nextResult = Q(yield* Await(nextResult));
+      if (!(nextResult instanceof ObjectValue)) {
+        return Throw.TypeError('The return value ($1) of the next() on an iterator ($2) must be an object', nextResult, iteratorRecord.Iterator);
+      }
+      const done = Q(yield* IteratorComplete(nextResult));
+      if (done === Value.true) {
+        Q(yield* Set(array, Value('length'), F(k), Value.true));
+        return array;
+      }
+
+      const nextValue: ValueCompletion<Value> = Q(yield* IteratorValue(nextResult));
+      let mappedValue;
+      if (mapping) {
+        mappedValue = (yield* Call(mapper, thisArg, [nextValue, F(k)]));
+        IfAbruptCloseAsyncIterator(mappedValue, iteratorRecord);
+        __ts_cast__<Value>(mappedValue);
+        mappedValue = yield* Await(mappedValue);
+        IfAbruptCloseAsyncIterator(mappedValue, iteratorRecord);
+        __ts_cast__<Value>(mappedValue);
+      } else {
+        mappedValue = nextValue;
+      }
+
+      const defineStatus = yield* CreateDataPropertyOrThrow(array, Pk, mappedValue);
+      IfAbruptCloseAsyncIterator(defineStatus, iteratorRecord);
+      k += 1;
+    }
+  } else {
+    const arrayLike = X(ToObject(items));
+    const len = Q(yield* LengthOfArrayLike(arrayLike));
+
+    let array: ObjectValue;
+    if (IsConstructor(constructor)) {
+      array = Q(yield* Construct(constructor, [F(len)]));
+    } else {
+      array = Q(ArrayCreate(len));
+    }
+
+    let k = 0;
+    while (k < len) {
+      const Pk = X(ToString(F(k)));
+      let kValue = Q(yield* Get(arrayLike, Pk));
+      kValue = Q(yield* Await(kValue));
+      let mappedValue: Value;
+      if (mapping) {
+        mappedValue = Q(yield* Call(mapper, thisArg, [kValue, F(k)]));
+        mappedValue = Q(yield* Await(mappedValue));
+      } else {
+        mappedValue = kValue;
+      }
+      Q(yield* CreateDataPropertyOrThrow(array, Pk, mappedValue));
+      k += 1;
+    }
+
+    Q(yield* Set(array, Value('length'), F(len), Value.true));
+    return array;
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-array.isarray */
+function Array_isArray([arg = Value.undefined]: Arguments): ValueCompletion {
+  return Q(IsArray(arg));
+}
+
+/** https://tc39.es/ecma262/#sec-array.of */
+function* Array_of(items: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  const len = items.length;
+  // Let items be the List of arguments passed to this function.
+  const constructor = thisValue;
+  let array;
+  if (IsConstructor(constructor)) {
+    array = Q(yield* Construct(constructor, [F(len)]));
+  } else {
+    array = Q(ArrayCreate(len));
+  }
+  let k = 0;
+  while (k < len) {
+    const kValue = items[k]!;
+    const Pk = X(ToString(F(k)));
+    Q(yield* CreateDataPropertyOrThrow(array, Pk, kValue));
+    k += 1;
+  }
+  Q(yield* Set(array, Value('length'), F(len), Value.true));
+  return array;
+}
+
+/** https://tc39.es/ecma262/#sec-get-array-@@species */
+function Array_speciesGetter(_args: Arguments, { thisValue }: FunctionCallContext) {
+  return thisValue;
+}
+
+export function bootstrapArray(realmRec: Realm) {
+  const proto = realmRec.Intrinsics['%Array.prototype%'];
+
+  const cons = bootstrapConstructor(realmRec, ArrayConstructor, 'Array', 1, proto, [
+    ['from', Array_from, 1],
+    ['fromAsync', Array_fromAsync, 1, undefined, true],
+    ['isArray', Array_isArray, 1],
+    ['of', Array_of, 0],
+    [wellKnownSymbols.species, [Array_speciesGetter]],
+  ]);
+
+  realmRec.Intrinsics['%Array%'] = cons;
+}