@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/FunctionPrototype.mts

@@ -0,0 +1,232 @@
+import {
+  HostHasSourceTextAvailable,
+} from '../host-defined/engine.mts';
+import {
+  JSStringValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  Q, X, type ValueCompletion, type ValueEvaluator,
+} from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../utils/language.mts';
+import { assignProps } from './bootstrap.mts';
+import {
+  Assert,
+  Call,
+  Construct,
+  CreateListFromArrayLike,
+  IsCallable,
+  IsConstructor,
+  OrdinaryHasInstance,
+  PrepareForTailCall,
+  SameValue,
+  CreateBuiltinFunction,
+  MakeBasicObject,
+  type ExoticObject,
+  type FunctionObject,
+  isBuiltinFunctionObject,
+  hasSourceTextInternalSlot,
+  CopyNameAndLength,
+  Realm,
+  Throw,
+  type BaseFunctionObject,
+} from '#self';
+
+export interface BoundFunctionObject extends ExoticObject, BaseFunctionObject {
+  readonly BoundTargetFunction: FunctionObject;
+  readonly BoundThis: Value;
+  readonly BoundArguments: Arguments;
+}
+
+export function isBoundFunctionObject(object: object): object is BoundFunctionObject {
+  return 'BoundTargetFunction' in object;
+}
+
+/** https://tc39.es/ecma262/#sec-properties-of-the-function-prototype-object */
+function FunctionProto() {
+  // * accepts any arguments and returns undefined when invoked.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.apply */
+function* FunctionProto_apply([thisArg = Value.undefined, argArray = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let func be the this value.
+  const func = thisValue;
+  // 2. If IsCallable(func) is false, throw a TypeError exception.
+  if (!IsCallable(func)) {
+    return Throw.TypeError("Expected 'this' value to be a function but got $1", func);
+  }
+  // 3. If argArray is undefined or null, then
+  if (argArray === Value.undefined || argArray === Value.null) {
+    // a. Perform PrepareForTailCall().
+    PrepareForTailCall();
+    // b. Return ? Call(func, thisArg).
+    return Q(yield* Call(func, thisArg));
+  }
+  // 4. Let argList be ? CreateListFromArrayLike(argArray).
+  const argList = Q(yield* CreateListFromArrayLike(argArray));
+  // 5. Perform PrepareForTailCall().
+  PrepareForTailCall();
+  // 6. Return ? Call(func, thisArg, argList).
+  return Q(yield* Call(func, thisArg, argList));
+}
+
+function* BoundFunctionExoticObjectCall(this: BoundFunctionObject, _thisArgument: ObjectValue, argumentsList: Arguments): ValueEvaluator {
+  const F = this;
+
+  const target = F.BoundTargetFunction;
+  const boundThis = F.BoundThis;
+  const boundArgs = F.BoundArguments;
+  const args = [...boundArgs.values(), ...argumentsList.values()];
+  return Q(yield* Call(target, boundThis, args));
+}
+
+function* BoundFunctionExoticObjectConstruct(this: BoundFunctionObject, argumentsList: Arguments, newTarget: FunctionObject | UndefinedValue): ValueEvaluator<ObjectValue> {
+  const F = this;
+
+  const target = F.BoundTargetFunction;
+  Assert(IsConstructor(target));
+  const boundArgs = F.BoundArguments;
+  const args = [...boundArgs.values(), ...argumentsList.values()];
+  if (SameValue(F, newTarget)) {
+    newTarget = target;
+  }
+  return Q(yield* Construct(target, args, newTarget));
+}
+
+/** https://tc39.es/ecma262/#sec-boundfunctioncreate */
+function* BoundFunctionCreate(targetFunction: ObjectValue, boundThis: Value, boundArgs: Arguments): ValueEvaluator<BoundFunctionObject> {
+  // 1. Assert: Type(targetFunction) is Object.
+  Assert(targetFunction instanceof ObjectValue);
+  // 2. Let proto be ? targetFunction.[[GetPrototypeOf]]().
+  const proto = Q(yield* targetFunction.GetPrototypeOf());
+  // 3. Let internalSlotsList be the internal slots listed in Table 30, plus [[Prototype]] and [[Extensible]].
+  const internalSlotsList = [
+    'BoundTargetFunction',
+    'BoundThis',
+    'BoundArguments',
+    'Prototype',
+    'Extensible',
+  ];
+  // 4. Let obj be ! MakeBasicObject(internalSlotsList).
+  const obj = X(MakeBasicObject(internalSlotsList)) as Mutable<BoundFunctionObject>;
+  // 5. Set obj.[[Prototype]] to proto.
+  obj.Prototype = proto;
+  // 6. Set obj.[[Call]] as described in 9.4.1.1.
+  obj.Call = BoundFunctionExoticObjectCall;
+  // 7. If IsConstructor(targetFunction) is true, then
+  if (IsConstructor(targetFunction)) {
+    // a. Set obj.[[Construct]] as described in 9.4.1.2.
+    obj.Construct = BoundFunctionExoticObjectConstruct;
+  }
+  // 8. Set obj.[[BoundTargetFunction]] to targetFunction.
+  obj.BoundTargetFunction = targetFunction as FunctionObject;
+  // 9. Set obj.[[BoundThis]] to boundThis.
+  obj.BoundThis = boundThis;
+  // 10. Set obj.[[BoundArguments]] to boundArguments.
+  obj.BoundArguments = boundArgs;
+  // 11. Return obj.
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.bind */
+function* FunctionProto_bind([thisArg = Value.undefined, ...args]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let Target be the this value.
+  const Target = thisValue;
+  // 2. If IsCallable(Target) is false, throw a TypeError exception.
+  if (!IsCallable(Target)) {
+    return Throw.TypeError("Expected 'this' value to be a function but got $1", Target);
+  }
+  __ts_cast__<ObjectValue>(Target);
+  // 3. Let F be ? BoundFunctionCreate(Target, thisArg, args).
+  const F = Q(yield* BoundFunctionCreate(Target, thisArg, args as Arguments));
+  Q(yield* CopyNameAndLength(F, Target, 'bound', args.length));
+  return F;
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.call */
+function* FunctionProto_call([thisArg = Value.undefined, ...args]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let func be the this value.
+  const func = thisValue;
+  // 2. If IsCallable(func) is false, throw a TypeError exception.
+  if (!IsCallable(func)) {
+    return Throw.TypeError("Expected 'this' value to be a function but got $1", func);
+  }
+  // 3. Let argList be a new empty List.
+  const argList: Value[] = [];
+  // 4. If this method was called with more than one argument, then in left to right order, starting with the second argument, append each argument as the last element of argList.
+  for (const arg of args) {
+    argList.push(arg!);
+  }
+  // 5. Perform PrepareForTailCall().
+  PrepareForTailCall();
+  // 6. Return ? Call(func, thisArg, argList).
+  return Q(yield* Call(func, thisArg, argList));
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.tostring */
+export function FunctionProto_toString(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion<JSStringValue> {
+  // 1. Let func be the this value.
+  const func = thisValue;
+  // 2. If Type(func) is Object and func has a [[SourceText]] internal slot and func.[[SourceText]]
+  //    is a sequence of Unicode code points and ! HostHasSourceTextAvailable(func) is true, then
+  if (hasSourceTextInternalSlot(func)
+    && X(HostHasSourceTextAvailable(func)) === Value.true) {
+    // Return ! UTF16Encode(func.[[SourceText]]).
+    return Value(func.SourceText);
+  }
+  // 3. If func is a built-in function object, then return an implementation-defined
+  //    String source code representation of func. The representation must have the
+  //    syntax of a NativeFunction. Additionally, if func has an [[InitialName]] internal
+  //    slot and func.[[InitialName]] is a String, the portion of the returned String
+  //    that would be matched by `NativeFunctionAccessor? PropertyName` must be the
+  //    value of func.[[InitialName]].
+  if (isBuiltinFunctionObject(func)) {
+    if (func.InitialName instanceof JSStringValue) {
+      return Value(`function ${func.InitialName.stringValue()}() { [native code] }`);
+    }
+    return Value('function() { [native code] }');
+  }
+  // 4. If Type(func) is Object and IsCallable(func) is true, then return an implementation
+  //    dependent String source code representation of func. The representation must have
+  //    the syntax of a NativeFunction.
+  if (func instanceof ObjectValue && IsCallable(func)) {
+    return Value('function() { [native code] }');
+  }
+  // 5. Throw a TypeError exception.
+  return Throw.TypeError('$1 is not a function', func);
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype-@@hasinstance */
+function* FunctionProto_hasInstance([V = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let F be this value.
+  const F = thisValue;
+  // 2. Return ? OrdinaryHasInstance(F, V).
+  return Q(yield* OrdinaryHasInstance(F, V));
+}
+
+export function bootstrapFunctionPrototype(realmRec: Realm) {
+  const proto = CreateBuiltinFunction(
+    FunctionProto,
+    0,
+    Value(''),
+    [],
+    realmRec,
+    realmRec.Intrinsics['%Object.prototype%'],
+  );
+  realmRec.Intrinsics['%Function.prototype%'] = proto;
+
+  const readonly = { Writable: Value.false, Configurable: Value.false };
+  assignProps(realmRec, proto, [
+    ['apply', FunctionProto_apply, 2],
+    ['bind', FunctionProto_bind, 1],
+    ['call', FunctionProto_call, 1],
+    ['toString', FunctionProto_toString, 0],
+    [wellKnownSymbols.hasInstance, FunctionProto_hasInstance, 1, readonly],
+  ]);
+}

package/src/intrinsics/GeneratorFunction.mts

@@ -0,0 +1,38 @@
+import {
+  Descriptor, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { Q, X, type ValueEvaluator } from '../completion.mts';
+import { CreateDynamicFunction } from '../runtime-semantics/all.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import { DefinePropertyOrThrow, type FunctionObject, Realm } from '#self';
+
+/** https://tc39.es/ecma262/#sec-generatorfunction */
+function* GeneratorFunctionConstructor(args: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  const bodyArg = args[args.length - 1] || Value('');
+  args = args.slice(0, -1) as Arguments;
+  // 1. Let C be the active function object.
+  const activeFunc = surroundingAgent.activeFunctionObject as FunctionObject;
+  // 2. Let args be the argumentsList that was passed to this function by [[Call]] or [[Construct]].
+  // 3. Return ? CreateDynamicFunction(C, NewTarget, generator, args).
+  return Q(yield* CreateDynamicFunction(activeFunc, NewTarget, 'generator', args, bodyArg));
+}
+
+export function bootstrapGeneratorFunction(realmRec: Realm) {
+  const generator = realmRec.Intrinsics['%GeneratorFunction.prototype%'];
+
+  const cons = bootstrapConstructor(realmRec, GeneratorFunctionConstructor, 'GeneratorFunction', 1, generator, []);
+
+  X(DefinePropertyOrThrow(cons, Value('prototype'), Descriptor({
+    Writable: Value.false,
+    Configurable: Value.false,
+  })));
+
+  X(DefinePropertyOrThrow(generator, Value('constructor'), Descriptor({
+    Writable: Value.false,
+  })));
+
+  cons.Prototype = realmRec.Intrinsics['%Function%'];
+
+  realmRec.Intrinsics['%GeneratorFunction%'] = cons;
+}

package/src/intrinsics/GeneratorFunctionPrototype.mts

@@ -0,0 +1,22 @@
+import { Descriptor, Value } from '../value.mts';
+import { X } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import { DefinePropertyOrThrow } from '#self';
+import type { Realm } from '#self';
+
+export function bootstrapGeneratorFunctionPrototype(realmRec: Realm) {
+  const generatorPrototype = realmRec.Intrinsics['%GeneratorFunction.prototype.prototype%'];
+
+  const generator = bootstrapPrototype(realmRec, [
+    ['prototype', generatorPrototype, undefined, { Writable: Value.false }],
+  ], realmRec.Intrinsics['%Function.prototype%'], 'GeneratorFunction');
+
+  X(DefinePropertyOrThrow(generatorPrototype, Value('constructor'), Descriptor({
+    Value: generator,
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+
+  realmRec.Intrinsics['%GeneratorFunction.prototype%'] = generator;
+}

package/src/intrinsics/GeneratorFunctionPrototypePrototype.mts

@@ -0,0 +1,59 @@
+import {
+  Completion,
+  ThrowCompletion,
+  Q,
+  X,
+  type ValueEvaluator,
+} from '../completion.mts';
+import {
+  Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import {
+  GeneratorResume,
+  GeneratorResumeAbrupt,
+  type FunctionObject,
+  Realm,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-generator.prototype.next */
+function* GeneratorProto_next([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let g be the this value.
+  const g = thisValue;
+  // 2. Return ? GeneratorResume(g, value, empty).
+  return Q(yield* GeneratorResume(g, value, undefined));
+}
+
+/** https://tc39.es/ecma262/#sec-generator.prototype.return */
+function* GeneratorProto_return([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let g be the this value.
+  const g = thisValue;
+  // 2. Let C be Completion { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
+  const completion = new Completion({ Type: 'return', Value: value, Target: undefined });
+  // 3. Return ? GeneratorResumeAbrupt(g, C, empty).
+  return Q(yield* GeneratorResumeAbrupt(g, completion, undefined));
+}
+
+/** https://tc39.es/ecma262/#sec-generator.prototype.throw */
+function* GeneratorProto_throw([exception = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let g be the this value.
+  const g = thisValue;
+  // 2. Let C be ThrowCompletion(exception).
+  const completion = ThrowCompletion(exception);
+  // 3. Return ? GeneratorResumeAbrupt(g, C, empty).
+  return Q(yield* GeneratorResumeAbrupt(g, completion, undefined));
+}
+
+export function bootstrapGeneratorFunctionPrototypePrototype(realmRec: Realm) {
+  const generatorPrototype = bootstrapPrototype(realmRec, [
+    ['next', GeneratorProto_next, 1],
+    ['return', GeneratorProto_return, 1],
+    ['throw', GeneratorProto_throw, 1],
+  ], realmRec.Intrinsics['%Iterator.prototype%'], 'Generator');
+
+  realmRec.Intrinsics['%GeneratorFunction.prototype.prototype%'] = generatorPrototype;
+  realmRec.Intrinsics['%GeneratorPrototype%'] = realmRec.Intrinsics['%GeneratorFunction.prototype.prototype%'];
+
+  // Used by `CreateListIteratorRecord`:
+  realmRec.Intrinsics['%GeneratorFunction.prototype.prototype.next%'] = X(generatorPrototype.Get(Value('next'), generatorPrototype)) as FunctionObject;
+}

package/src/intrinsics/Iterator.mts

@@ -0,0 +1,302 @@
+import {
+  AbruptCompletion,
+  IfAbruptCloseIterators,
+  NormalCompletion,
+  Q,
+  X,
+  type ValueEvaluator,
+} from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../utils/language.mts';
+import {
+  JSStringValue,
+  ObjectValue,
+  type PropertyKeyValue,
+  type BooleanValue,
+  UndefinedValue,
+  Value,
+  type Arguments,
+  type FunctionCallContext,
+  wellKnownSymbols,
+} from '../value.mts';
+import { type IteratorZipMode, IteratorZip } from '../abstract-ops/iterator-operations.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import {
+  Call,
+  CreateArrayFromList,
+  CreateDataPropertyOrThrow,
+  CreateIteratorFromClosure,
+  Get,
+  GetIterator,
+  GetIteratorDirect,
+  GetIteratorFlattenable,
+  GetMethod,
+  IteratorClose,
+  IteratorStepValue,
+  OrdinaryCreateFromConstructor,
+  OrdinaryHasInstance,
+  OrdinaryObjectCreate,
+  Yield,
+  type BuiltinFunctionObject,
+  type FunctionObject,
+  type IteratorRecord,
+  type IteratorObject,
+  type Realm,
+  Throw,
+  type YieldEvaluator,
+  GetOptionsObject,
+} from '#self';
+
+
+/** https://tc39.es/ecma262/multipage/control-abstraction-objects.html#sec-iterator-constructor */
+function* IteratorConstructor(
+  this: BuiltinFunctionObject,
+  _args: Arguments,
+  { NewTarget }: FunctionCallContext,
+): ValueEvaluator<ObjectValue> {
+  // 1. If NewTarget is either undefined or the active function object, throw a TypeError exception.
+  if (NewTarget instanceof UndefinedValue) {
+    return Throw.TypeError('Iterator cannot be invoked without new');
+  }
+  if (NewTarget === surroundingAgent.activeFunctionObject) {
+    return Throw.TypeError('Iterator is an abstract class');
+  }
+
+  // 2. Return ? OrdinaryCreateFromConstructor(NewTarget, "%Iterator.prototype%").
+  return Q(yield* OrdinaryCreateFromConstructor(NewTarget, '%Iterator.prototype%'));
+}
+
+/** https://tc39.es/ecma262/#sec-iterator.from */
+function* Iterator_from([O = Value.undefined]: Arguments): ValueEvaluator {
+  // 1. Let iteratorRecord be ? GetIteratorFlattenable(O, iterate-string-primitives).
+  const iteratorRecord = Q(yield* GetIteratorFlattenable(O, 'iterate-string-primitives'));
+
+  // 2. Let hasInstance be ? OrdinaryHasInstance(%Iterator%, iteratorRecord.[[Iterator]]).
+  const hasInstance: BooleanValue = Q(yield* OrdinaryHasInstance(surroundingAgent.intrinsic('%Iterator%'), iteratorRecord.Iterator));
+  // 3. If hasInstance is true, then
+  if (hasInstance === Value.true) {
+    // a. Return iteratorRecord.[[Iterator]].
+    return iteratorRecord.Iterator;
+  }
+
+  // 4. Let wrapper be OrdinaryObjectCreate(%WrapForValidIteratorPrototype%, « [[Iterated]] »).
+  const wrapper = OrdinaryObjectCreate(
+    surroundingAgent.intrinsic('%WrapForValidIteratorPrototype%'),
+    ['Iterated'],
+  ) as Mutable<IteratorObject>;
+  // 5. Set wrapper.[[Iterated]] to iteratorRecord.
+  wrapper.Iterated = iteratorRecord;
+  // 6. Return wrapper.
+  return wrapper;
+}
+
+/** https://tc39.es/ecma262/#sec-iterator.concat */
+function* Iterator_concat(items: Arguments): ValueEvaluator {
+  const iterables: { OpenMethod: FunctionObject, Iterable: ObjectValue }[] = [];
+  for (const item of items.values()) {
+    if (!(item instanceof ObjectValue)) {
+      return Throw.TypeError('$1 is not an object', item);
+    }
+    const method = Q(yield* GetMethod(item, wellKnownSymbols.iterator));
+    if (method instanceof UndefinedValue) {
+      return Throw.TypeError('$1 is not iterable', item);
+    }
+    iterables.push({ OpenMethod: method, Iterable: item });
+  }
+  const gen = CreateIteratorFromClosure(function* Iterator_concat(): YieldEvaluator {
+    for (const iterable of iterables) {
+      const iter = Q(yield* Call(iterable.OpenMethod, iterable.Iterable));
+      if (!(iter instanceof ObjectValue)) {
+        return Throw.TypeError('$1 is not iterable', iter);
+      }
+      const iteratorRecord = Q(yield* GetIteratorDirect(iter));
+      let innerAlive = true;
+      while (innerAlive) {
+        const innerValue = Q(yield* IteratorStepValue(iteratorRecord));
+        if (innerValue === 'done') {
+          innerAlive = false;
+        } else {
+          const completion = yield* Yield(innerValue);
+          if (completion instanceof AbruptCompletion) {
+            return Q(yield* IteratorClose(iteratorRecord, completion));
+          }
+        }
+      }
+    }
+    return Value.undefined;
+  }, Value('Iterator Helper'), surroundingAgent.intrinsic('%IteratorHelperPrototype%'), ['UnderlyingIterators']);
+  gen.UnderlyingIterators = [];
+  return gen;
+}
+
+/** https://tc39.es/ecma262/#sec-iterator.zip */
+function* Iterator_zip([iterables = Value.undefined, _options = Value.undefined]: Arguments): ValueEvaluator {
+  if (!(iterables instanceof ObjectValue)) {
+    return Throw.TypeError('$1 is not an object', iterables);
+  }
+  const options = Q(GetOptionsObject(_options));
+
+  const modeOption = Q(yield* Get(options, Value('mode')));
+  let mode: IteratorZipMode;
+  if (modeOption === Value.undefined) mode = 'shortest';
+  else if (!(modeOption instanceof JSStringValue)) {
+    return Throw.TypeError('Iterator.zip mode must be one of "shortest", "longest", or "strict"');
+  } else {
+    const modeString = modeOption.stringValue();
+    if (modeString !== 'shortest' && modeString !== 'longest' && modeString !== 'strict') {
+      return Throw.TypeError('Iterator.zip mode must be one of "shortest", "longest", or "strict"');
+    }
+    mode = modeString;
+  }
+
+  let paddingOption: Value = Value.undefined;
+  if (mode === 'longest') {
+    paddingOption = Q(yield* Get(options, Value('padding')));
+    if (paddingOption !== Value.undefined && !(paddingOption instanceof ObjectValue)) {
+      return Throw.TypeError('options.padding $1 is not an object', paddingOption);
+    }
+  }
+  __ts_cast__<UndefinedValue | ObjectValue>(paddingOption);
+
+  const iters: IteratorRecord[] = [];
+  const padding: Value[] = [];
+  const inputIter = Q(yield* GetIterator(iterables, 'sync'));
+
+  let next: 'not-started' | Value | 'done' = 'not-started';
+  while (next !== 'done') {
+    const _next = yield* IteratorStepValue(inputIter);
+    IfAbruptCloseIterators(_next, iters);
+    next = X(_next);
+    if (next !== 'done') {
+      const iter = yield* GetIteratorFlattenable(next, 'reject-primitives');
+      const needsClosing = [inputIter, ...iters];
+      IfAbruptCloseIterators(iter, needsClosing);
+      iters.push(X(iter));
+    }
+  }
+
+  const iterCount = iters.length;
+  if (mode === 'longest') {
+    if (paddingOption === Value.undefined) {
+      for (let i = 0; i < iterCount; i += 1) {
+        padding.push(Value.undefined);
+      }
+    } else {
+      const _paddingIter = yield* GetIterator(paddingOption, 'sync');
+      IfAbruptCloseIterators(_paddingIter, iters);
+      const paddingIter = X(_paddingIter);
+
+      let usingIterator = true;
+      for (let i = 0; i < iterCount; i += 1) {
+        if (usingIterator === true) {
+          const _next = yield* IteratorStepValue(paddingIter);
+          IfAbruptCloseIterators(_next, iters);
+          next = X(_next);
+          if (next === 'done') {
+            usingIterator = false;
+          } else {
+            padding.push(next);
+          }
+        }
+        if (usingIterator === false) padding.push(Value.undefined);
+      }
+
+      if (usingIterator === true) {
+        const completion = yield* IteratorClose(paddingIter, NormalCompletion(undefined));
+        IfAbruptCloseIterators(completion, iters);
+      }
+    }
+  }
+
+  const finishResults = (results: readonly Value[]) => CreateArrayFromList(results);
+  return IteratorZip(iters, mode, padding, finishResults);
+}
+
+/** https://tc39.es/ecma262/#sec-iterator.zipkeyed */
+function* Iterator_zipKeyed([iterables = Value.undefined, _options = Value.undefined]: Arguments): ValueEvaluator {
+  if (!(iterables instanceof ObjectValue)) {
+    return Throw.TypeError('$1 is not an object', iterables);
+  }
+  const options = Q(GetOptionsObject(_options));
+
+  const modeOption = Q(yield* Get(options, Value('mode')));
+  let mode: IteratorZipMode;
+  if (modeOption === Value.undefined) mode = 'shortest';
+  else if (!(modeOption instanceof JSStringValue)) {
+    return Throw.TypeError('Iterator.zipKeyed mode must be one of "shortest", "longest", or "strict"');
+  } else {
+    const modeString = modeOption.stringValue();
+    if (modeString !== 'shortest' && modeString !== 'longest' && modeString !== 'strict') {
+      return Throw.TypeError('Iterator.zipKeyed mode must be one of "shortest", "longest", or "strict"');
+    }
+    mode = modeString;
+  }
+
+  let paddingOption: Value = Value.undefined;
+  if (mode === 'longest') {
+    paddingOption = Q(yield* Get(options, Value('padding')));
+    if (paddingOption !== Value.undefined && !(paddingOption instanceof ObjectValue)) {
+      return Throw.TypeError('option.padding $1 is not an object', paddingOption);
+    }
+  }
+
+  const iters: IteratorRecord[] = [];
+  const padding: Value[] = [];
+  const allKeys: PropertyKeyValue[] = Q(yield* iterables.OwnPropertyKeys());
+  const keys: PropertyKeyValue[] = [];
+
+  for (const key of allKeys) {
+    const _propertyDesc = yield* iterables.GetOwnProperty(key);
+    IfAbruptCloseIterators(_propertyDesc, iters);
+    const propertyDesc = X(_propertyDesc);
+    if (!(propertyDesc instanceof UndefinedValue) && propertyDesc.Enumerable === Value.true) {
+      const _value = yield* Get(iterables, key);
+      IfAbruptCloseIterators(_value, iters);
+      const value = X(_value);
+      if (value !== Value.undefined) {
+        keys.push(key);
+        const _iter = yield* GetIteratorFlattenable(value, 'reject-primitives');
+        IfAbruptCloseIterators(_iter, iters);
+        const iter = X(_iter);
+        iters.push(iter);
+      }
+    }
+  }
+
+  const iterCount = iters.length;
+  if (mode === 'longest') {
+    if (paddingOption === Value.undefined) {
+      for (let i = 0; i < iterCount; i += 1) {
+        padding.push(Value.undefined);
+      }
+    } else {
+      __ts_cast__<ObjectValue>(paddingOption);
+      for (const key of keys) {
+        const _value = yield* Get(paddingOption, key);
+        IfAbruptCloseIterators(_value, iters);
+        const value = X(_value);
+        padding.push(value);
+      }
+    }
+  }
+
+  const finishResults = (results: readonly Value[]) => {
+    const obj = OrdinaryObjectCreate(Value.null);
+    for (let i = 0; i < iterCount; i += 1) {
+      X(CreateDataPropertyOrThrow(obj, keys[i], results[i]));
+    }
+    return obj;
+  };
+  return IteratorZip(iters, mode, padding, finishResults);
+}
+
+export function bootstrapIterator(realmRec: Realm) {
+  const cons = bootstrapConstructor(realmRec, IteratorConstructor, 'Iterator', 0, realmRec.Intrinsics['%Iterator.prototype%'], [
+    ['from', Iterator_from, 1],
+    ['concat', Iterator_concat, 0],
+    ['zip', Iterator_zip, 1],
+    ['zipKeyed', Iterator_zipKeyed, 1],
+  ]);
+
+  realmRec.Intrinsics['%Iterator%'] = cons;
+}