core-js 3.23.3 → 3.24.0

package/actual/typed-array/index.js

@@ -3,6 +3,7 @@ require('../../modules/esnext.typed-array.find-last');
 require('../../modules/esnext.typed-array.find-last-index');
 require('../../modules/esnext.typed-array.to-reversed');
 require('../../modules/esnext.typed-array.to-sorted');
+// TODO: Remove from `core-js@4`
 require('../../modules/esnext.typed-array.to-spliced');
 require('../../modules/esnext.typed-array.with');
 

package/actual/typed-array/methods.js

@@ -3,6 +3,7 @@ require('../../modules/esnext.typed-array.find-last');
 require('../../modules/esnext.typed-array.find-last-index');
 require('../../modules/esnext.typed-array.to-reversed');
 require('../../modules/esnext.typed-array.to-sorted');
+// TODO: Remove from `core-js@4`
 require('../../modules/esnext.typed-array.to-spliced');
 require('../../modules/esnext.typed-array.with');
 

package/actual/typed-array/to-spliced.js

@@ -1 +1,2 @@
+// TODO: Remove from `core-js@4`
 require('../../modules/esnext.typed-array.to-spliced');

package/features/async-iterator/indexed.js

@@ -0,0 +1 @@
+module.exports = require('../../full/async-iterator/indexed');

package/features/iterator/indexed.js

@@ -0,0 +1 @@
+module.exports = require('../../full/iterator/indexed');

package/full/async-iterator/index.js

@@ -3,6 +3,7 @@ require('../../modules/es.object.to-string');
 require('../../modules/es.promise');
 require('../../modules/es.string.iterator');
 require('../../modules/esnext.async-iterator.constructor');
+// TODO: Remove from `core-js@4`
 require('../../modules/esnext.async-iterator.as-indexed-pairs');
 require('../../modules/esnext.async-iterator.drop');
 require('../../modules/esnext.async-iterator.every');
@@ -11,6 +12,7 @@ require('../../modules/esnext.async-iterator.find');
 require('../../modules/esnext.async-iterator.flat-map');
 require('../../modules/esnext.async-iterator.for-each');
 require('../../modules/esnext.async-iterator.from');
+require('../../modules/esnext.async-iterator.indexed');
 require('../../modules/esnext.async-iterator.map');
 require('../../modules/esnext.async-iterator.reduce');
 require('../../modules/esnext.async-iterator.some');

package/full/async-iterator/indexed.js

@@ -0,0 +1,8 @@
+require('../../modules/es.object.to-string');
+require('../../modules/es.promise');
+require('../../modules/esnext.async-iterator.constructor');
+require('../../modules/esnext.async-iterator.indexed');
+
+var entryUnbind = require('../../internals/entry-unbind');
+
+module.exports = entryUnbind('AsyncIterator', 'indexed');

package/full/index.js

@@ -258,6 +258,7 @@ require('../modules/esnext.async-iterator.find');
 require('../modules/esnext.async-iterator.flat-map');
 require('../modules/esnext.async-iterator.for-each');
 require('../modules/esnext.async-iterator.from');
+require('../modules/esnext.async-iterator.indexed');
 require('../modules/esnext.async-iterator.map');
 require('../modules/esnext.async-iterator.reduce');
 require('../modules/esnext.async-iterator.some');
@@ -279,6 +280,7 @@ require('../modules/esnext.iterator.find');
 require('../modules/esnext.iterator.flat-map');
 require('../modules/esnext.iterator.for-each');
 require('../modules/esnext.iterator.from');
+require('../modules/esnext.iterator.indexed');
 require('../modules/esnext.iterator.map');
 require('../modules/esnext.iterator.reduce');
 require('../modules/esnext.iterator.some');

package/full/iterator/index.js

@@ -3,6 +3,7 @@ require('../../modules/es.object.to-string');
 require('../../modules/es.promise');
 require('../../modules/es.string.iterator');
 require('../../modules/esnext.iterator.constructor');
+// TODO: Remove from `core-js@4`
 require('../../modules/esnext.iterator.as-indexed-pairs');
 require('../../modules/esnext.iterator.drop');
 require('../../modules/esnext.iterator.every');
@@ -11,6 +12,7 @@ require('../../modules/esnext.iterator.find');
 require('../../modules/esnext.iterator.flat-map');
 require('../../modules/esnext.iterator.for-each');
 require('../../modules/esnext.iterator.from');
+require('../../modules/esnext.iterator.indexed');
 require('../../modules/esnext.iterator.map');
 require('../../modules/esnext.iterator.reduce');
 require('../../modules/esnext.iterator.some');

package/full/iterator/indexed.js

@@ -0,0 +1,8 @@
+require('../../modules/es.object.to-string');
+require('../../modules/esnext.iterator.constructor');
+require('../../modules/esnext.iterator.indexed');
+
+var entryUnbind = require('../../internals/entry-unbind');
+
+module.exports = entryUnbind('Iterator', 'indexed');
+

package/full/typed-array/to-spliced.js

@@ -1,3 +1,4 @@
+// TODO: Remove from `core-js@4`
 var parent = require('../../actual/typed-array/to-spliced');
 
 module.exports = parent;

package/internals/async-from-sync-iterator.js

@@ -1,5 +1,5 @@
 'use strict';
-var apply = require('../internals/function-apply');
+var call = require('../internals/function-call');
 var anObject = require('../internals/an-object');
 var create = require('../internals/object-create');
 var getMethod = require('../internals/get-method');
@@ -30,31 +30,19 @@ var AsyncFromSyncIterator = function AsyncIterator(iterator) {
 };
 
 AsyncFromSyncIterator.prototype = defineBuiltIns(create(AsyncIteratorPrototype), {
-  next: function next(arg) {
+  next: function next() {
     var state = getInternalState(this);
-    var hasArg = !!arguments.length;
     return new Promise(function (resolve, reject) {
-      var result = anObject(apply(state.next, state.iterator, hasArg ? [arg] : []));
+      var result = anObject(call(state.next, state.iterator));
       asyncFromSyncIteratorContinuation(result, resolve, reject);
     });
   },
-  'return': function (arg) {
+  'return': function () {
     var iterator = getInternalState(this).iterator;
-    var hasArg = !!arguments.length;
     return new Promise(function (resolve, reject) {
       var $return = getMethod(iterator, 'return');
-      if ($return === undefined) return resolve({ done: true, value: arg });
-      var result = anObject(apply($return, iterator, hasArg ? [arg] : []));
-      asyncFromSyncIteratorContinuation(result, resolve, reject);
-    });
-  },
-  'throw': function (arg) {
-    var iterator = getInternalState(this).iterator;
-    var hasArg = !!arguments.length;
-    return new Promise(function (resolve, reject) {
-      var $throw = getMethod(iterator, 'throw');
-      if ($throw === undefined) return reject(arg);
-      var result = anObject(apply($throw, iterator, hasArg ? [arg] : []));
+      if ($return === undefined) return resolve({ done: true, value: undefined });
+      var result = anObject(call($return, iterator));
       asyncFromSyncIteratorContinuation(result, resolve, reject);
     });
   }

package/internals/async-iterator-close.js

@@ -0,0 +1,18 @@
+var call = require('../internals/function-call');
+var getBuiltIn = require('../internals/get-built-in');
+var getMethod = require('../internals/get-method');
+
+module.exports = function (iterator, method, argument, reject) {
+  try {
+    var returnMethod = getMethod(iterator, 'return');
+    if (returnMethod) {
+      return getBuiltIn('Promise').resolve(call(returnMethod, iterator)).then(function () {
+        method(argument);
+      }, function (error) {
+        reject(error);
+      });
+    }
+  } catch (error2) {
+    return reject(error2);
+  } method(argument);
+};

package/internals/async-iterator-create-proxy.js

@@ -1,6 +1,6 @@
 'use strict';
 var call = require('../internals/function-call');
-var aCallable = require('../internals/a-callable');
+var perform = require('../internals/perform');
 var anObject = require('../internals/an-object');
 var create = require('../internals/object-create');
 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
@@ -10,65 +10,118 @@ var InternalStateModule = require('../internals/internal-state');
 var getBuiltIn = require('../internals/get-built-in');
 var getMethod = require('../internals/get-method');
 var AsyncIteratorPrototype = require('../internals/async-iterator-prototype');
+var iteratorClose = require('../internals/iterator-close');
 
 var Promise = getBuiltIn('Promise');
 
-var ASYNC_ITERATOR_PROXY = 'AsyncIteratorProxy';
+var ASYNC_ITERATOR_HELPER = 'AsyncIteratorHelper';
+var WRAP_FOR_VALID_ASYNC_ITERATOR = 'WrapForValidAsyncIterator';
 var setInternalState = InternalStateModule.set;
-var getInternalState = InternalStateModule.getterFor(ASYNC_ITERATOR_PROXY);
 
 var TO_STRING_TAG = wellKnownSymbol('toStringTag');
 
-module.exports = function (nextHandler, IS_ITERATOR) {
-  var AsyncIteratorProxy = function AsyncIterator(state) {
-    state.type = ASYNC_ITERATOR_PROXY;
-    state.next = aCallable(state.iterator.next);
-    state.done = false;
-    state.ignoreArgument = !IS_ITERATOR;
-    setInternalState(this, state);
+var createAsyncIteratorProxyPrototype = function (IS_ITERATOR) {
+  var IS_GENERATOR = !IS_ITERATOR;
+  var ASYNC_ITERATOR_PROXY = IS_ITERATOR ? WRAP_FOR_VALID_ASYNC_ITERATOR : ASYNC_ITERATOR_HELPER;
+
+  var getInternalState = InternalStateModule.getterFor(ASYNC_ITERATOR_PROXY);
+
+  var getStateOrEarlyExit = function (that) {
+    var stateCompletion = perform(function () {
+      return getInternalState(that);
+    });
+
+    var stateError = stateCompletion.error;
+    var state = stateCompletion.value;
+
+    if (stateError || (IS_GENERATOR && state.done)) {
+      return { exit: true, value: stateError ? Promise.reject(state) : Promise.resolve({ done: true, value: undefined }) };
+    } return { exit: false, value: state };
   };
 
-  AsyncIteratorProxy.prototype = defineBuiltIns(create(AsyncIteratorPrototype), {
-    next: function next(arg) {
-      var that = this;
-      var hasArgument = !!arguments.length;
-      return new Promise(function (resolve) {
-        var state = getInternalState(that);
-        var args = hasArgument ? [state.ignoreArgument ? undefined : arg] : IS_ITERATOR ? [] : [undefined];
-        state.ignoreArgument = false;
-        resolve(state.done ? { done: true, value: undefined } : anObject(call(nextHandler, state, Promise, args)));
-      });
-    },
-    'return': function (value) {
-      var that = this;
-      return new Promise(function (resolve, reject) {
-        var state = getInternalState(that);
-        var iterator = state.iterator;
-        state.done = true;
-        var $$return = getMethod(iterator, 'return');
-        if ($$return === undefined) return resolve({ done: true, value: value });
-        Promise.resolve(call($$return, iterator, value)).then(function (result) {
-          anObject(result);
-          resolve({ done: true, value: value });
-        }, reject);
+  var enqueue = function (state, handler) {
+    var task = function () {
+      var promise = handler();
+      if (IS_GENERATOR) {
+        state.awaiting = promise;
+        var clean = function () {
+          if (state.awaiting === promise) state.awaiting = null;
+        };
+        promise.then(clean, clean);
+      } return promise;
+    };
+
+    return state.awaiting ? state.awaiting = state.awaiting.then(task, task) : task();
+  };
+
+  var AsyncIteratorProxyPrototype = defineBuiltIns(create(AsyncIteratorPrototype), {
+    next: function next() {
+      var stateCompletion = getStateOrEarlyExit(this);
+      var exit = stateCompletion.exit;
+      var state = stateCompletion.value;
+
+      return exit ? state : enqueue(state, function () {
+        var handlerCompletion = perform(function () {
+          return anObject(state.nextHandler(Promise));
+        });
+        var handlerError = handlerCompletion.error;
+        var value = handlerCompletion.value;
+        if (handlerError) state.done = true;
+        return handlerError ? Promise.reject(value) : Promise.resolve(value);
       });
     },
-    'throw': function (value) {
-      var that = this;
-      return new Promise(function (resolve, reject) {
-        var state = getInternalState(that);
-        var iterator = state.iterator;
-        state.done = true;
-        var $$throw = getMethod(iterator, 'throw');
-        if ($$throw === undefined) return reject(value);
-        resolve(call($$throw, iterator, value));
+    'return': function () {
+      var stateCompletion = getStateOrEarlyExit(this);
+      var exit = stateCompletion.exit;
+      var state = stateCompletion.value;
+
+      return exit ? state : enqueue(state, function () {
+        return new Promise(function (resolve, reject) {
+          var iterator = state.iterator;
+          var innerIterator = state.innerIterator;
+          state.done = true;
+          if (innerIterator) try {
+            iteratorClose(innerIterator, 'return');
+          } catch (error) {
+            return iteratorClose(iterator, 'throw', error);
+          }
+          var $$return = getMethod(iterator, 'return');
+          if ($$return === undefined) return resolve({ done: true, value: undefined });
+          Promise.resolve(call($$return, iterator)).then(function (result) {
+            anObject(result);
+            resolve({ done: true, value: undefined });
+          }, reject);
+        });
       });
     }
   });
 
-  if (!IS_ITERATOR) {
-    createNonEnumerableProperty(AsyncIteratorProxy.prototype, TO_STRING_TAG, 'Generator');
+  if (IS_GENERATOR) {
+    createNonEnumerableProperty(AsyncIteratorProxyPrototype, TO_STRING_TAG, 'Async Iterator Helper');
   }
 
+  return AsyncIteratorProxyPrototype;
+};
+
+var AsyncIteratorHelperPrototype = createAsyncIteratorProxyPrototype(false);
+var WrapForValidAsyncIteratorPrototype = createAsyncIteratorProxyPrototype(true);
+
+module.exports = function (nextHandler, IS_ITERATOR) {
+  var ASYNC_ITERATOR_PROXY = IS_ITERATOR ? WRAP_FOR_VALID_ASYNC_ITERATOR : ASYNC_ITERATOR_HELPER;
+
+  var AsyncIteratorProxy = function AsyncIterator(record, state) {
+    if (state) {
+      state.iterator = record.iterator;
+      state.next = record.next;
+    } else state = record;
+    state.type = ASYNC_ITERATOR_PROXY;
+    state.nextHandler = nextHandler;
+    state.done = false;
+    state.awaiting = null;
+    setInternalState(this, state);
+  };
+
+  AsyncIteratorProxy.prototype = IS_ITERATOR ? WrapForValidAsyncIteratorPrototype : AsyncIteratorHelperPrototype;
+
   return AsyncIteratorProxy;
 };

package/internals/async-iterator-indexed.js

@@ -0,0 +1,28 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var call = require('../internals/function-call');
+var anObject = require('../internals/an-object');
+var getIteratorDirect = require('../internals/get-iterator-direct');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise) {
+  var state = this;
+  var iterator = state.iterator;
+
+  return Promise.resolve(anObject(call(state.next, iterator))).then(function (step) {
+    if (anObject(step).done) {
+      state.done = true;
+      return { done: true, value: undefined };
+    }
+    return { done: false, value: [state.index++, step.value] };
+  }).then(null, function (error) {
+    state.done = true;
+    throw error;
+  });
+});
+
+module.exports = function indexed() {
+  return new AsyncIteratorProxy(getIteratorDirect(this), {
+    index: 0
+  });
+};

package/internals/async-iterator-iteration.js

@@ -6,44 +6,33 @@ var aCallable = require('../internals/a-callable');
 var anObject = require('../internals/an-object');
 var doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');
 var getBuiltIn = require('../internals/get-built-in');
-var getMethod = require('../internals/get-method');
+var getIteratorDirect = require('../internals/get-iterator-direct');
+var closeAsyncIteration = require('../internals/async-iterator-close');
 
 var createMethod = function (TYPE) {
   var IS_TO_ARRAY = TYPE == 0;
   var IS_FOR_EACH = TYPE == 1;
   var IS_EVERY = TYPE == 2;
   var IS_SOME = TYPE == 3;
-  return function (iterator, fn, target) {
-    anObject(iterator);
+  return function (object, fn, target) {
+    var record = getIteratorDirect(object);
     var Promise = getBuiltIn('Promise');
-    var next = aCallable(iterator.next);
+    var iterator = record.iterator;
+    var next = record.next;
     var index = 0;
     var MAPPING = fn !== undefined;
     if (MAPPING || !IS_TO_ARRAY) aCallable(fn);
 
     return new Promise(function (resolve, reject) {
-      var closeIteration = function (method, argument) {
-        try {
-          var returnMethod = getMethod(iterator, 'return');
-          if (returnMethod) {
-            return Promise.resolve(call(returnMethod, iterator)).then(function () {
-              method(argument);
-            }, function (error) {
-              reject(error);
-            });
-          }
-        } catch (error2) {
-          return reject(error2);
-        } method(argument);
-      };
-
-      var onError = function (error) {
-        closeIteration(reject, error);
+      var ifAbruptCloseAsyncIterator = function (error) {
+        closeAsyncIteration(iterator, reject, error, reject);
       };
 
       var loop = function () {
         try {
-          if (IS_TO_ARRAY && MAPPING) doesNotExceedSafeInteger(index);
+          if (IS_TO_ARRAY && MAPPING) try {
+            doesNotExceedSafeInteger(index);
+          } catch (error5) { ifAbruptCloseAsyncIterator(error5); }
           Promise.resolve(anObject(call(next, iterator))).then(function (step) {
             try {
               if (anObject(step).done) {
@@ -53,27 +42,31 @@ var createMethod = function (TYPE) {
                 } else resolve(IS_SOME ? false : IS_EVERY || undefined);
               } else {
                 var value = step.value;
-                if (MAPPING) {
-                  Promise.resolve(IS_TO_ARRAY ? fn(value, index) : fn(value)).then(function (result) {
-                    if (IS_FOR_EACH) {
-                      loop();
-                    } else if (IS_EVERY) {
-                      result ? loop() : closeIteration(resolve, false);
-                    } else if (IS_TO_ARRAY) {
-                      target[index++] = result;
-                      loop();
-                    } else {
-                      result ? closeIteration(resolve, IS_SOME || value) : loop();
-                    }
-                  }, onError);
-                } else {
-                  target[index++] = value;
-                  loop();
-                }
+                try {
+                  if (MAPPING) {
+                    Promise.resolve(IS_TO_ARRAY ? fn(value, index) : fn(value)).then(function (result) {
+                      if (IS_FOR_EACH) {
+                        loop();
+                      } else if (IS_EVERY) {
+                        result ? loop() : closeAsyncIteration(iterator, resolve, false, reject);
+                      } else if (IS_TO_ARRAY) {
+                        try {
+                          target[index++] = result;
+                          loop();
+                        } catch (error4) { ifAbruptCloseAsyncIterator(error4); }
+                      } else {
+                        result ? closeAsyncIteration(iterator, resolve, IS_SOME || value, reject) : loop();
+                      }
+                    }, ifAbruptCloseAsyncIterator);
+                  } else {
+                    target[index++] = value;
+                    loop();
+                  }
+                } catch (error3) { ifAbruptCloseAsyncIterator(error3); }
               }
-            } catch (error) { onError(error); }
-          }, onError);
-        } catch (error2) { onError(error2); }
+            } catch (error2) { reject(error2); }
+          }, reject);
+        } catch (error) { reject(error); }
       };
 
       loop();

package/internals/async-iterator-wrap.js

@@ -0,0 +1,6 @@
+var call = require('../internals/function-call');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+
+module.exports = createAsyncIteratorProxy(function () {
+  return call(this.next, this.iterator);
+}, true);

package/internals/get-iterator-direct.js

@@ -0,0 +1,9 @@
+var aCallable = require('../internals/a-callable');
+var anObject = require('../internals/an-object');
+
+module.exports = function (obj) {
+  return {
+    iterator: obj,
+    next: aCallable(anObject(obj).next)
+  };
+};

package/internals/iterate.js

@@ -21,6 +21,7 @@ var ResultPrototype = Result.prototype;
 module.exports = function (iterable, unboundFunction, options) {
   var that = options && options.that;
   var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+  var IS_RECORD = !!(options && options.IS_RECORD);
   var IS_ITERATOR = !!(options && options.IS_ITERATOR);
   var INTERRUPTED = !!(options && options.INTERRUPTED);
   var fn = bind(unboundFunction, that);
@@ -38,7 +39,9 @@ module.exports = function (iterable, unboundFunction, options) {
     } return INTERRUPTED ? fn(value, stop) : fn(value);
   };
 
-  if (IS_ITERATOR) {
+  if (IS_RECORD) {
+    iterator = iterable.iterator;
+  } else if (IS_ITERATOR) {
     iterator = iterable;
   } else {
     iterFn = getIteratorMethod(iterable);
@@ -53,7 +56,7 @@ module.exports = function (iterable, unboundFunction, options) {
     iterator = getIterator(iterable, iterFn);
   }
 
-  next = iterator.next;
+  next = IS_RECORD ? iterable.next : iterator.next;
   while (!(step = call(next, iterator)).done) {
     try {
       result = callFn(step.value);

package/internals/iterator-create-proxy.js

@@ -1,6 +1,5 @@
 'use strict';
 var call = require('../internals/function-call');
-var aCallable = require('../internals/a-callable');
 var anObject = require('../internals/an-object');
 var create = require('../internals/object-create');
 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
@@ -9,50 +8,74 @@ var wellKnownSymbol = require('../internals/well-known-symbol');
 var InternalStateModule = require('../internals/internal-state');
 var getMethod = require('../internals/get-method');
 var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;
+var iteratorClose = require('../internals/iterator-close');
 
-var ITERATOR_PROXY = 'IteratorProxy';
+var ITERATOR_HELPER = 'IteratorHelper';
+var WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator';
 var setInternalState = InternalStateModule.set;
-var getInternalState = InternalStateModule.getterFor(ITERATOR_PROXY);
 
 var TO_STRING_TAG = wellKnownSymbol('toStringTag');
 
-module.exports = function (nextHandler, IS_ITERATOR) {
-  var IteratorProxy = function Iterator(state) {
-    state.type = ITERATOR_PROXY;
-    state.next = aCallable(state.iterator.next);
-    state.done = false;
-    state.ignoreArg = !IS_ITERATOR;
-    setInternalState(this, state);
-  };
+var createIteratorProxyPrototype = function (IS_ITERATOR) {
+  var ITERATOR_PROXY = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
+
+  var getInternalState = InternalStateModule.getterFor(ITERATOR_PROXY);
 
-  IteratorProxy.prototype = defineBuiltIns(create(IteratorPrototype), {
-    next: function next(arg) {
+  var IteratorProxyPrototype = defineBuiltIns(create(IteratorPrototype), {
+    next: function next() {
       var state = getInternalState(this);
-      var args = arguments.length ? [state.ignoreArg ? undefined : arg] : IS_ITERATOR ? [] : [undefined];
-      state.ignoreArg = false;
-      var result = state.done ? undefined : call(nextHandler, state, args);
-      return { done: state.done, value: result };
+      // for simplification:
+      //   for `%WrapForValidIteratorPrototype%.next` our `nextHandler` returns `IterResultObject`
+      //   for `%IteratorHelperPrototype%.next` - just a value
+      if (IS_ITERATOR) return state.nextHandler();
+      try {
+        var result = state.done ? undefined : state.nextHandler();
+        return { done: state.done, value: result };
+      } catch (error) {
+        state.done = true;
+        throw error;
+      }
     },
-    'return': function (value) {
+    'return': function () {
       var state = getInternalState(this);
       var iterator = state.iterator;
+      var innerIterator = state.innerIterator;
       state.done = true;
+      if (innerIterator) try {
+        iteratorClose(innerIterator, 'return');
+      } catch (error) {
+        return iteratorClose(iterator, 'throw', error);
+      }
       var $$return = getMethod(iterator, 'return');
-      return { done: true, value: $$return ? anObject(call($$return, iterator, value)).value : value };
-    },
-    'throw': function (value) {
-      var state = getInternalState(this);
-      var iterator = state.iterator;
-      state.done = true;
-      var $$throw = getMethod(iterator, 'throw');
-      if ($$throw) return call($$throw, iterator, value);
-      throw value;
+      return { done: true, value: $$return ? anObject(call($$return, iterator)).value : undefined };
     }
   });
 
   if (!IS_ITERATOR) {
-    createNonEnumerableProperty(IteratorProxy.prototype, TO_STRING_TAG, 'Generator');
+    createNonEnumerableProperty(IteratorProxyPrototype, TO_STRING_TAG, 'Iterator Helper');
   }
 
+  return IteratorProxyPrototype;
+};
+
+var IteratorHelperPrototype = createIteratorProxyPrototype(false);
+var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
+
+module.exports = function (nextHandler, IS_ITERATOR) {
+  var ITERATOR_PROXY = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
+
+  var IteratorProxy = function Iterator(record, state) {
+    if (state) {
+      state.iterator = record.iterator;
+      state.next = record.next;
+    } else state = record;
+    state.type = ITERATOR_PROXY;
+    state.nextHandler = nextHandler;
+    state.done = false;
+    setInternalState(this, state);
+  };
+
+  IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;
+
   return IteratorProxy;
 };