@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/abstract-ops/all.mts

@@ -0,0 +1,35 @@
+export * from './arguments-operations.mts';
+export * from './array-objects.mts';
+export * from './arraybuffer-objects.mts';
+export * from './async-function-operations.mts';
+export * from './async-generator-objects.mts';
+export * from './data-types-and-values.mts';
+export * from './dataview-objects.mts';
+export * from './date-objects.mts';
+export * from './error-objects.mts';
+export * from './execution-contexts.mts';
+export * from './function-operations.mts';
+export * from './generator-operations.mts';
+export * from './global-object.mts';
+export * from './immutable-prototype-objects.mts';
+export * from './import-calls.mts';
+export * from './iterator-operations.mts';
+export * from './keyed-collections.mts';
+export * from './module-namespace-exotic-objects.mts';
+export * from './module-records.mts';
+export * from './notational-conventions.mts';
+export * from './object-operations.mts';
+export * from './objects.mts';
+export * from './private-names.mts';
+export * from './promise-operations.mts';
+export * from './proxy-objects.mts';
+export * from './realms.mts';
+export * from './reference-operations.mts';
+export * from './regexp-objects.mts';
+export * from './spec-types.mts';
+export * from './string-objects.mts';
+export * from './symbol-objects.mts';
+export * from './testing-comparison.mts';
+export * from './type-conversion.mts';
+export * from './typedarray-objects.mts';
+export * from './weak-operations.mts';

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

@@ -0,0 +1,245 @@
+import {
+  Q, X, BoundNames, surroundingAgent,
+  JSStringSet, type Mutable, type ParseNode,
+  Assert,
+  CreateBuiltinFunction,
+  CreateDataProperty,
+  DefinePropertyOrThrow,
+  ToString,
+  SameValue,
+  MakeBasicObject,
+  OrdinaryObjectCreate,
+  OrdinaryGetOwnProperty,
+  OrdinaryDefineOwnProperty,
+  OrdinaryGet,
+  OrdinarySet,
+  OrdinaryDelete,
+  Get,
+  Set,
+  HasOwnProperty,
+  IsAccessorDescriptor,
+  IsDataDescriptor,
+  F,
+  type OrdinaryObject,
+  Descriptor,
+  JSStringValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type ObjectInternalMethods,
+  EnvironmentRecord,
+} from '#self';
+
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-arguments-exotic-objects */
+export interface MappedArgumentsObject extends OrdinaryObject {
+  readonly ParameterMap: ObjectValue;
+}
+export interface UnmappedArgumentsObject extends OrdinaryObject {
+  readonly ParameterMap: UndefinedValue;
+}
+
+export function isArgumentExoticObject(value: Value): value is MappedArgumentsObject | UnmappedArgumentsObject {
+  return 'ParameterMap' in value;
+}
+
+const ArgumentExoticObject = {
+  * GetOwnProperty(P) {
+    const args = this;
+    const desc = OrdinaryGetOwnProperty(args, P);
+    if (desc === Value.undefined) {
+      return desc;
+    }
+    const map = args.ParameterMap;
+    const isMapped = X(HasOwnProperty(map, P));
+    if (isMapped === Value.true) {
+      return Descriptor({ ...desc, Value: Q(yield* Get(map, P)) });
+    }
+    return desc;
+  },
+  * DefineOwnProperty(P, Desc) {
+    const args = this;
+    const map = args.ParameterMap;
+    const isMapped = X(HasOwnProperty(map, P));
+    let newArgDesc = Desc;
+    if (isMapped === Value.true && IsDataDescriptor(Desc) === true) {
+      if (Desc.Value === undefined && Desc.Writable !== undefined && Desc.Writable === Value.false) {
+        newArgDesc = Descriptor({ ...Desc, Value: X(Get(map, P)) });
+      }
+    }
+    const allowed = Q(yield* OrdinaryDefineOwnProperty(args, P, newArgDesc));
+    if (allowed === Value.false) {
+      return Value.false;
+    }
+    if (isMapped === Value.true) {
+      if (IsAccessorDescriptor(Desc) === true) {
+        yield* map.Delete(P);
+      } else {
+        if (Desc.Value !== undefined) {
+          const setStatus = yield* Set(map, P, Desc.Value, Value.false);
+          Assert(setStatus === Value.true);
+        }
+        if (Desc.Writable !== undefined && Desc.Writable === Value.false) {
+          yield* map.Delete(P);
+        }
+      }
+    }
+    return Value.true;
+  },
+  * Get(P, Receiver) {
+    const args = this;
+    const map = args.ParameterMap;
+    const isMapped = X(HasOwnProperty(map, P));
+    if (isMapped === Value.false) {
+      return Q(yield* OrdinaryGet(args, P, Receiver));
+    } else {
+      return yield* Get(map, P);
+    }
+  },
+  * Set(P, V, Receiver) {
+    const args = this;
+    let isMapped;
+    let map;
+    if (SameValue(args, Receiver) === Value.false) {
+      isMapped = false;
+    } else {
+      map = args.ParameterMap;
+      isMapped = X(HasOwnProperty(map, P)) === Value.true;
+    }
+    if (isMapped) {
+      const setStatus = yield* Set(map!, P, V, Value.false);
+      Assert(setStatus === Value.true);
+    }
+    return Q(yield* OrdinarySet(args, P, V, Receiver));
+  },
+  * Delete(P) {
+    const args = this;
+    const map = args.ParameterMap;
+    const isMapped = X(HasOwnProperty(map, P));
+    const result = Q(yield* OrdinaryDelete(args, P));
+    if (result === Value.true && isMapped === Value.true) {
+      yield* map.Delete(P);
+    }
+    return result;
+  },
+} satisfies Partial<ObjectInternalMethods<MappedArgumentsObject>>;
+
+/** https://tc39.es/ecma262/#sec-createunmappedargumentsobject */
+export function CreateUnmappedArgumentsObject(argumentsList: Arguments) {
+  const len = argumentsList.length;
+  const obj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'), ['ParameterMap']) as Mutable<UnmappedArgumentsObject>;
+  obj.ParameterMap = Value.undefined;
+  X(DefinePropertyOrThrow(obj, Value('length'), Descriptor({
+    Value: F(len),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  let index = 0;
+  while (index < len) {
+    const val = argumentsList[index];
+    X(CreateDataProperty(obj, X(ToString(F(index))), val));
+    index += 1;
+  }
+  X(DefinePropertyOrThrow(obj, wellKnownSymbols.iterator, Descriptor({
+    Value: surroundingAgent.intrinsic('%Array.prototype.values%'),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  X(DefinePropertyOrThrow(obj, Value('callee'), Descriptor({
+    Get: surroundingAgent.intrinsic('%ThrowTypeError%'),
+    Set: surroundingAgent.intrinsic('%ThrowTypeError%'),
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-makearggetter */
+function MakeArgGetter(name: JSStringValue, env: EnvironmentRecord) {
+  // 1. Let getterClosure be a new Abstract Closure with no parameters that captures name and env and performs the following steps when called:
+  //   a. Return env.GetBindingValue(name, false).
+  const getterClosure = () => env.GetBindingValue(name, Value.false);
+  // 2. Let getter be ! CreateBuiltinFunction(getterClosure, 0, "", « »).
+  const getter = X(CreateBuiltinFunction(getterClosure, 0, Value(''), ['Name', 'Env']));
+  // 3. NOTE: getter is never directly accessible to ECMAScript code.
+  // 4. Return getter.
+  return getter;
+}
+
+/** https://tc39.es/ecma262/#sec-makeargsetter */
+function MakeArgSetter(name: JSStringValue, env: EnvironmentRecord) {
+  // 1. Let setterClosure be a new Abstract Closure with parameters (value) that captures name and env and performs the following steps when called:
+  //   a. Return env.SetMutableBinding(name, value, false).
+  const setterClosure = ([value = Value.undefined]: Arguments) => env.SetMutableBinding(name, value, Value.false);
+  // 2. Let setter be ! CreateBuiltinFunction(setterClosure, 1, "", « »).
+  const setter = X(CreateBuiltinFunction(setterClosure, 1, Value(''), ['Name', 'Env']));
+  // 3. NOTE: setter is never directly accessible to ECMAScript code.
+  // 4. Return setter.
+  return setter;
+}
+
+/** https://tc39.es/ecma262/#sec-createmappedargumentsobject */
+export function CreateMappedArgumentsObject(func: ObjectValue, formals: ParseNode.FormalParameters, argumentsList: Arguments, env: EnvironmentRecord) {
+  // Assert: formals does not contain a rest parameter, any binding
+  // patterns, or any initializers. It may contain duplicate identifiers.
+  const len = argumentsList.length;
+  const obj = X(MakeBasicObject(['Prototype', 'Extensible', 'ParameterMap']));
+  obj.GetOwnProperty = ArgumentExoticObject.GetOwnProperty;
+  obj.DefineOwnProperty = ArgumentExoticObject.DefineOwnProperty;
+  obj.Get = ArgumentExoticObject.Get;
+  obj.Set = ArgumentExoticObject.Set;
+  obj.Delete = ArgumentExoticObject.Delete;
+  obj.Prototype = surroundingAgent.intrinsic('%Object.prototype%');
+  const map = OrdinaryObjectCreate(Value.null);
+  obj.ParameterMap = map;
+  const parameterNames = BoundNames(formals);
+  const numberOfParameters = parameterNames.length;
+  let index = 0;
+  while (index < len) {
+    const val = argumentsList[index];
+    X(CreateDataProperty(obj, X(ToString(F(index))), val));
+    index += 1;
+  }
+  X(DefinePropertyOrThrow(obj, Value('length'), Descriptor({
+    Value: F(len),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  const mappedNames = new JSStringSet();
+  index = numberOfParameters - 1;
+  while (index >= 0) {
+    const name = parameterNames[index];
+    if (!mappedNames.has(name)) {
+      mappedNames.add(name);
+      if (index < len) {
+        const g = MakeArgGetter(name, env);
+        const p = MakeArgSetter(name, env);
+        X(map.DefineOwnProperty(X(ToString(F(index))), Descriptor({
+          Set: p,
+          Get: g,
+          Enumerable: Value.false,
+          Configurable: Value.true,
+        })));
+      }
+    }
+    index -= 1;
+  }
+  X(DefinePropertyOrThrow(obj, wellKnownSymbols.iterator, Descriptor({
+    Value: surroundingAgent.intrinsic('%Array.prototype.values%'),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  X(DefinePropertyOrThrow(obj, Value('callee'), Descriptor({
+    Value: func,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+  return obj;
+}

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

@@ -0,0 +1,312 @@
+import {
+  surroundingAgent, Descriptor, ObjectValue, JSStringValue, Value, wellKnownSymbols, type ObjectInternalMethods,
+  NumberValue, UndefinedValue,
+  BooleanValue,
+  Q, X, type ValueCompletion, type ValueEvaluator,
+  type Mutable, type YieldEvaluator,
+  AbstractRelationalComparison,
+  Assert,
+  Call,
+  Construct,
+  CreateArrayFromList,
+  CreateIteratorFromClosure,
+  Get,
+  GetFunctionRealm,
+  IsDataDescriptor,
+  IsArray,
+  IsConstructor,
+  OrdinaryDefineOwnProperty,
+  OrdinaryGetOwnProperty,
+  LengthOfArrayLike,
+  MakeBasicObject,
+  SameValue,
+  ToBoolean,
+  ToNumber,
+  ToString,
+  ToUint32,
+  IsPropertyKey,
+  isArrayIndex,
+  isNonNegativeInteger,
+  F, R,
+  type OrdinaryObject,
+  type FunctionObject,
+  type GeneratorObject,
+  MakeTypedArrayWithBufferWitnessRecord,
+  IsTypedArrayOutOfBounds,
+  TypedArrayLength,
+  CreateIteratorResultObject,
+  GeneratorYield,
+} from '#self';
+import { isTypedArrayObject } from '#self';
+
+const InternalMethods = {
+  /** https://tc39.es/ecma262/#sec-array-exotic-objects-defineownproperty-p-desc */
+  * DefineOwnProperty(P, Desc): ValueEvaluator<BooleanValue> {
+    const A = this;
+
+    Assert(IsPropertyKey(P));
+    if (P instanceof JSStringValue && P.stringValue() === 'length') {
+      return Q(yield* ArraySetLength(A, Desc));
+    } else if (isArrayIndex(P)) {
+      let lengthDesc = OrdinaryGetOwnProperty(A, Value('length'));
+      Assert(!(lengthDesc instanceof UndefinedValue));
+      Assert(IsDataDescriptor(lengthDesc));
+      Assert(lengthDesc.Configurable === Value.false);
+      const length = lengthDesc.Value;
+      Assert(length instanceof NumberValue && isNonNegativeInteger(R(length)));
+      const index = X(ToUint32(P));
+      if (R(index) >= R(length) && lengthDesc.Writable === Value.false) {
+        return Value.false;
+      }
+      let succeeded = X(OrdinaryDefineOwnProperty(A, P, Desc));
+      if (succeeded === Value.false) {
+        return Value.false;
+      }
+      if (R(index) >= R(length)) {
+        lengthDesc = Descriptor({ ...lengthDesc, Value: F(R(index) + 1) });
+        succeeded = X(OrdinaryDefineOwnProperty(A, Value('length'), lengthDesc));
+        Assert(succeeded === Value.true);
+      }
+      return Value.true;
+    }
+    return yield* OrdinaryDefineOwnProperty(A, P, Desc);
+  },
+} satisfies Partial<ObjectInternalMethods<OrdinaryObject>>;
+
+export function isArrayExoticObject(O: Value) {
+  return O instanceof ObjectValue && O.DefineOwnProperty === InternalMethods.DefineOwnProperty;
+}
+
+/** https://tc39.es/ecma262/#sec-arraycreate */
+export function ArrayCreate(length: number, proto?: ObjectValue): ValueCompletion<OrdinaryObject> {
+  Assert(isNonNegativeInteger(length));
+  if (Object.is(length, -0)) {
+    length = +0;
+  }
+  if (length > (2 ** 32) - 1) {
+    return surroundingAgent.Throw('RangeError', 'InvalidArrayLength', length);
+  }
+  if (proto === undefined) {
+    proto = surroundingAgent.intrinsic('%Array.prototype%');
+  }
+  const A = X(MakeBasicObject(['Prototype', 'Extensible'])) as Mutable<OrdinaryObject>;
+  A.Prototype = proto;
+  A.DefineOwnProperty = InternalMethods.DefineOwnProperty;
+
+  X(OrdinaryDefineOwnProperty(A, Value('length'), Descriptor({
+    Value: F(length),
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+
+  return A;
+}
+
+/** https://tc39.es/ecma262/#sec-arrayspeciescreate */
+export function* ArraySpeciesCreate(originalArray: ObjectValue, length: number): ValueEvaluator<ObjectValue> {
+  Assert(typeof length === 'number' && Number.isInteger(length) && length >= 0);
+  if (Object.is(length, -0)) {
+    length = +0;
+  }
+  const isArray = Q(IsArray(originalArray));
+  if (isArray === Value.false) {
+    return Q(ArrayCreate(length));
+  }
+  let C = Q(yield* Get(originalArray, Value('constructor')));
+  if (IsConstructor(C)) {
+    const thisRealm = surroundingAgent.currentRealmRecord;
+    const realmC = Q(GetFunctionRealm(C));
+    if (thisRealm !== realmC) {
+      if (SameValue(C, realmC.Intrinsics['%Array%']) === Value.true) {
+        C = Value.undefined;
+      }
+    }
+  }
+  if (C instanceof ObjectValue) {
+    C = Q(yield* Get(C, wellKnownSymbols.species));
+    if (C === Value.null) {
+      C = Value.undefined;
+    }
+  }
+  if (C === Value.undefined) {
+    return Q(ArrayCreate(length));
+  }
+  if (!IsConstructor(C)) {
+    return surroundingAgent.Throw('TypeError', 'NotAConstructor', C);
+  }
+  return Q(yield* Construct(C, [F(length)]));
+}
+
+/** https://tc39.es/ecma262/#sec-arraysetlength */
+export function* ArraySetLength(A: OrdinaryObject, Desc: Descriptor): ValueEvaluator<BooleanValue> {
+  if (Desc.Value === undefined) {
+    return yield* OrdinaryDefineOwnProperty(A, Value('length'), Desc);
+  }
+  let newLenDesc = Desc;
+  const newLen = R(Q(yield* ToUint32(Desc.Value)));
+  const numberLen = R(Q(yield* ToNumber(Desc.Value)));
+  if (newLen !== numberLen) {
+    return surroundingAgent.Throw('RangeError', 'InvalidArrayLength', Desc.Value);
+  }
+  newLenDesc = Descriptor({ ...Desc, Value: F(newLen) });
+  const oldLenDesc = OrdinaryGetOwnProperty(A, Value('length'));
+  Assert(!(oldLenDesc instanceof UndefinedValue));
+  Assert(IsDataDescriptor(oldLenDesc));
+  Assert(oldLenDesc.Configurable === Value.false);
+  const oldLen = R(oldLenDesc.Value as NumberValue);
+  if (newLen >= oldLen) {
+    return yield* OrdinaryDefineOwnProperty(A, Value('length'), newLenDesc);
+  }
+  if (oldLenDesc.Writable === Value.false) {
+    return Value.false;
+  }
+  let newWritable;
+  if (newLenDesc.Writable === undefined || newLenDesc.Writable === Value.true) {
+    newWritable = true;
+  } else {
+    newWritable = false;
+    newLenDesc = Descriptor({ ...newLenDesc, Writable: Value.true });
+  }
+  const succeeded = X(OrdinaryDefineOwnProperty(A, Value('length'), newLenDesc));
+  if (succeeded === Value.false) {
+    return Value.false;
+  }
+  const keys: JSStringValue[] = [];
+  A.properties.forEach((_value, key) => {
+    if (isArrayIndex(key) && Number((key as JSStringValue).stringValue()) >= newLen) {
+      keys.push(key as JSStringValue);
+    }
+  });
+  keys.sort((a, b) => Number(b.stringValue()) - Number(a.stringValue()));
+  for (const P of keys) {
+    const deleteSucceeded = X(A.Delete(P));
+    if (deleteSucceeded === Value.false) {
+      newLenDesc = Descriptor({ ...newLenDesc, Value: F(R(X(ToUint32(P))) + 1) });
+      if (newWritable === false) {
+        newLenDesc = Descriptor({ ...newLenDesc, Writable: Value.false });
+      }
+      X(OrdinaryDefineOwnProperty(A, Value('length'), newLenDesc));
+      return Value.false;
+    }
+  }
+  if (newWritable === false) {
+    const s = yield* OrdinaryDefineOwnProperty(A, Value('length'), Descriptor({ Writable: Value.false }));
+    Assert(s === Value.true);
+  }
+  return Value.true;
+}
+
+/** https://tc39.es/ecma262/#sec-isconcatspreadable */
+export function* IsConcatSpreadable(O: Value): ValueEvaluator<BooleanValue> {
+  if (!(O instanceof ObjectValue)) {
+    return Value.false;
+  }
+  const spreadable = Q(yield* Get(O, wellKnownSymbols.isConcatSpreadable));
+  if (spreadable !== Value.undefined) {
+    return ToBoolean(spreadable);
+  }
+  return Q(IsArray(O));
+}
+
+/** https://tc39.es/ecma262/#sec-comparearrayelements */
+export function* CompareArrayElements(x: Value, y: Value, comparefn: FunctionObject | UndefinedValue): ValueEvaluator<NumberValue> {
+  // 1. If x and y are both undefined, return +0𝔽.
+  if (x === Value.undefined && y === Value.undefined) {
+    return F(+0);
+  }
+  // 2. If x is undefined, return 1𝔽.
+  if (x === Value.undefined) {
+    return F(1);
+  }
+  // 3. If y is undefined, return -1𝔽.
+  if (y === Value.undefined) {
+    return F(-1);
+  }
+  // 4. If comparefn is not undefined, then
+  if (comparefn !== Value.undefined) {
+    // a. Let v be ? ToNumber(? Call(comparefn, undefined, « x, y »)).
+    const v = Q(yield* ToNumber(Q(yield* Call(comparefn, Value.undefined, [x, y]))));
+    // b. If v is NaN, return +0𝔽.
+    if (v.isNaN()) {
+      return F(+0);
+    }
+    // c. Return v.
+    return v;
+  }
+  // 5. Let xString be ? ToString(x).
+  const xString = Q(yield* ToString(x));
+  // 6. Let yString be ? ToString(y).
+  const yString = Q(yield* ToString(y));
+  // 7. Let xSmaller be the result of performing Abstract Relational Comparison xString < yString.
+  const xSmaller = yield* AbstractRelationalComparison(xString, yString);
+  // 8. If xSmaller is true, return -1𝔽.
+  if (xSmaller === Value.true) {
+    return F(-1);
+  }
+  // 9. Let ySmaller be the result of performing Abstract Relational Comparison yString < xString.
+  const ySmaller = yield* AbstractRelationalComparison(yString, xString);
+  // 10. If ySmaller is true, return 1𝔽.
+  if (ySmaller === Value.true) {
+    return F(1);
+  }
+  // 11. Return +0𝔽.
+  return F(+0);
+}
+
+/** https://tc39.es/ecma262/#sec-createarrayiterator */
+export function CreateArrayIterator(array: ObjectValue, kind: 'key+value' | 'key' | 'value'): ValueCompletion<GeneratorObject> {
+  // 3. Let closure be a new Abstract Closure with no parameters that captures kind and array and performs the following steps when called:
+  const closure = function* closure(): YieldEvaluator {
+    // a. Let index be 0.
+    let index = 0;
+    // b. Repeat,
+    while (true) {
+      let len;
+      let result;
+      // i. If array has a [[TypedArrayName]] internal slot, then
+      if (isTypedArrayObject(array)) {
+        const taRecord = MakeTypedArrayWithBufferWitnessRecord(array, 'seq-cst');
+        if (IsTypedArrayOutOfBounds(taRecord)) {
+          return surroundingAgent.Throw('TypeError', 'TypedArrayOutOfBounds');
+        }
+        // 2. Let len be array.[[ArrayLength]].
+        len = TypedArrayLength(taRecord);
+      } else { // ii. Else,
+        // 1. Let len be ? LengthOfArrayLike(array).
+        len = Q(yield* LengthOfArrayLike(array));
+      }
+      // iii. If index ≥ len, return undefined.
+      if (index >= len) {
+        // NON_SPEC
+        generator.HostCapturedValues = undefined;
+        return Value.undefined;
+      }
+      const indexNumber = F(index);
+      // iv. If kind is key,
+      if (kind === 'key') {
+        result = indexNumber;
+      } else { // v. Else,
+        // 1. Let elementKey be ! ToString(indexNumber).
+        const elementKey = X(ToString(indexNumber));
+        // 2. Let elementValue be ? Get(array, elementKey).
+        const elementValue = Q(yield* Get(array, elementKey));
+        // 3. If kind is value, perform ? Yield(elementValue).
+        if (kind === 'value') {
+          result = elementValue;
+        } else { // 4. Else,
+          // a. Assert: kind is key+value.
+          Assert(kind === 'key+value');
+          // b. Perform ? Yield(! CreateArrayFromList(« 𝔽(index), elementValue »)).
+          result = CreateArrayFromList([indexNumber, elementValue]);
+        }
+      }
+      Q(yield* GeneratorYield(CreateIteratorResultObject(result, Value.false)));
+      // vi. Set index to index + 1.
+      index += 1;
+    }
+  };
+  // 4. Return CreateIteratorFromClosure(closure, "%ArrayIteratorPrototype%", %ArrayIteratorPrototype%).
+  const generator = CreateIteratorFromClosure(closure, Value('%ArrayIteratorPrototype%'), surroundingAgent.intrinsic('%ArrayIteratorPrototype%'), ['HostCapturedValues'], [array]);
+  return generator;
+}