core-js 3.48.0 → 3.50.0

package/internals/array-from-async.js

@@ -1,12 +1,11 @@
 'use strict';
 var bind = require('../internals/function-bind-context');
 var uncurryThis = require('../internals/function-uncurry-this');
-var toObject = require('../internals/to-object');
 var isConstructor = require('../internals/is-constructor');
 var getAsyncIterator = require('../internals/get-async-iterator');
-var getIterator = require('../internals/get-iterator');
+var getIterator = require('../internals/get-iterator-internal');
 var getIteratorDirect = require('../internals/get-iterator-direct');
-var getIteratorMethod = require('../internals/get-iterator-method');
+var getIteratorMethod = require('../internals/get-iterator-method-internal');
 var getMethod = require('../internals/get-method');
 var getBuiltIn = require('../internals/get-built-in');
 var getBuiltInPrototypeMethod = require('../internals/get-built-in-prototype-method');
@@ -32,20 +31,19 @@ SafeArrayIterator.prototype.next = function () {
 
 // `Array.fromAsync` method implementation
 // https://github.com/tc39/proposal-array-from-async
-module.exports = function fromAsync(asyncItems /* , mapfn = undefined, thisArg = undefined */) {
+module.exports = function fromAsync(items /* , mapfn = undefined, thisArg = undefined */) {
   var C = this;
   var argumentsLength = arguments.length;
   var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
   var thisArg = argumentsLength > 2 ? arguments[2] : undefined;
   return new (getBuiltIn('Promise'))(function (resolve) {
-    var O = toObject(asyncItems);
     if (mapfn !== undefined) mapfn = bind(mapfn, thisArg);
-    var usingAsyncIterator = getMethod(O, ASYNC_ITERATOR);
-    var usingSyncIterator = usingAsyncIterator ? undefined : getIteratorMethod(O) || safeArrayIterator;
+    var usingAsyncIterator = getMethod(items, ASYNC_ITERATOR);
+    var usingSyncIterator = usingAsyncIterator ? undefined : getIteratorMethod(items) || safeArrayIterator;
     var A = isConstructor(C) ? new C() : [];
     var iterator = usingAsyncIterator
-      ? getAsyncIterator(O, usingAsyncIterator)
-      : new AsyncFromSyncIterator(getIteratorDirect(getIterator(O, usingSyncIterator)));
+      ? getAsyncIterator(items, usingAsyncIterator)
+      : new AsyncFromSyncIterator(getIteratorDirect(getIterator(items, usingSyncIterator)));
     resolve(toArray(iterator, mapfn, A));
   });
 };

package/internals/array-from.js

@@ -8,20 +8,22 @@ var isConstructor = require('../internals/is-constructor');
 var lengthOfArrayLike = require('../internals/length-of-array-like');
 var createProperty = require('../internals/create-property');
 var setArrayLength = require('../internals/array-set-length');
-var getIterator = require('../internals/get-iterator');
-var getIteratorMethod = require('../internals/get-iterator-method');
+var getIterator = require('../internals/get-iterator-internal');
+var getIteratorMethod = require('../internals/get-iterator-method-internal');
+var iteratorClose = require('../internals/iterator-close');
+var doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');
 
 var $Array = Array;
 
 // `Array.from` method implementation
 // https://tc39.es/ecma262/#sec-array.from
 module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
-  var O = toObject(arrayLike);
   var IS_CONSTRUCTOR = isConstructor(this);
   var argumentsLength = arguments.length;
   var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
   var mapping = mapfn !== undefined;
   if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);
+  var O = toObject(arrayLike);
   var iteratorMethod = getIteratorMethod(O);
   var index = 0;
   var length, result, step, iterator, next, value;
@@ -31,8 +33,17 @@ module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undef
     iterator = getIterator(O, iteratorMethod);
     next = iterator.next;
     for (;!(step = call(next, iterator)).done; index++) {
+      try {
+        doesNotExceedSafeInteger(index);
+      } catch (error) {
+        iteratorClose(iterator, 'throw', error);
+      }
       value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
-      createProperty(result, index, value);
+      try {
+        createProperty(result, index, value);
+      } catch (error) {
+        iteratorClose(iterator, 'throw', error);
+      }
     }
   } else {
     length = lengthOfArrayLike(O);

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

@@ -41,19 +41,43 @@ var AsyncFromSyncIterator = function AsyncIterator(iteratorRecord) {
 AsyncFromSyncIterator.prototype = defineBuiltIns(create(AsyncIteratorPrototype), {
   next: function next() {
     var state = getInternalState(this);
+    var hasValue = arguments.length > 0;
+    var value = hasValue ? arguments[0] : undefined;
     return new Promise(function (resolve, reject) {
-      var result = anObject(call(state.next, state.iterator));
+      var result = anObject(hasValue ? call(state.next, state.iterator, value) : call(state.next, state.iterator));
       asyncFromSyncIteratorContinuation(result, resolve, reject, state.iterator, true);
     });
   },
   'return': function () {
-    var iterator = getInternalState(this).iterator;
+    var state = getInternalState(this);
+    var iterator = state.iterator;
+    var hasValue = arguments.length > 0;
+    var value = hasValue ? arguments[0] : undefined;
     return new Promise(function (resolve, reject) {
       var $return = getMethod(iterator, 'return');
-      if ($return === undefined) return resolve(createIterResultObject(undefined, true));
-      var result = anObject(call($return, iterator));
+      if ($return === undefined) return resolve(createIterResultObject(value, true));
+      var result = anObject(hasValue ? call($return, iterator, value) : call($return, iterator));
       asyncFromSyncIteratorContinuation(result, resolve, reject, iterator);
     });
+  },
+  'throw': function () {
+    var state = getInternalState(this);
+    var iterator = state.iterator;
+    var hasValue = arguments.length > 0;
+    var value = hasValue ? arguments[0] : undefined;
+    return new Promise(function (resolve, reject) {
+      var $throw = getMethod(iterator, 'throw');
+      if ($throw === undefined) {
+        try {
+          iteratorClose(iterator, 'normal');
+        } catch (error) {
+          return reject(error);
+        }
+        return reject(new TypeError('The iterator does not provide a throw method'));
+      }
+      var result = anObject(hasValue ? call($throw, iterator, value) : call($throw, iterator));
+      asyncFromSyncIteratorContinuation(result, resolve, reject, iterator, true);
+    });
   }
 });
 

package/internals/async-iterator-close.js

@@ -1,5 +1,6 @@
 'use strict';
 var call = require('../internals/function-call');
+var anObject = require('../internals/an-object');
 var getBuiltIn = require('../internals/get-built-in');
 var getMethod = require('../internals/get-method');
 
@@ -7,13 +8,20 @@ module.exports = function (iterator, method, argument, reject) {
   try {
     var returnMethod = getMethod(iterator, 'return');
     if (returnMethod) {
-      return getBuiltIn('Promise').resolve(call(returnMethod, iterator)).then(function () {
+      return getBuiltIn('Promise').resolve(call(returnMethod, iterator)).then(function (result) {
+        try {
+          if (method !== reject) anObject(result);
+        } catch (error3) {
+          reject(error3);
+          return;
+        }
         method(argument);
       }, function (error) {
-        reject(error);
+        method === reject ? method(argument) : reject(error);
       });
     }
   } catch (error2) {
-    return reject(error2);
+    // the original error (`argument`) takes priority over `return()` errors
+    return method === reject ? reject(argument) : reject(error2);
   } method(argument);
 };

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

@@ -11,7 +11,7 @@ var getBuiltIn = require('../internals/get-built-in');
 var getMethod = require('../internals/get-method');
 var AsyncIteratorPrototype = require('../internals/async-iterator-prototype');
 var createIterResultObject = require('../internals/create-iter-result-object');
-var iteratorClose = require('../internals/iterator-close');
+var cleanupState = require('../internals/iterator-cleanup-state');
 
 var Promise = getBuiltIn('Promise');
 
@@ -47,8 +47,18 @@ var createAsyncIteratorProxyPrototype = function (IS_ITERATOR) {
       });
       var handlerError = handlerCompletion.error;
       var value = handlerCompletion.value;
-      if (handlerError) state.done = true;
-      return handlerError ? Promise.reject(value) : Promise.resolve(value);
+      if (handlerError) {
+        state.done = true;
+        if (IS_GENERATOR) cleanupState(state);
+        return Promise.reject(value);
+      }
+      return IS_GENERATOR ? Promise.resolve(value).then(function (result) {
+        if (state.done) cleanupState(state);
+        return result;
+      }, function (error) {
+        cleanupState(state);
+        throw error;
+      }) : Promise.resolve(value);
     },
     'return': function () {
       var stateCompletion = getStateOrEarlyExit(this);
@@ -56,27 +66,56 @@ var createAsyncIteratorProxyPrototype = function (IS_ITERATOR) {
       if (stateCompletion.exit) return state;
       state.done = true;
       var iterator = state.iterator;
+      var inner = state.inner;
+      if (IS_GENERATOR) cleanupState(state);
       var returnMethod, result;
-      var completion = perform(function () {
-        if (state.inner) try {
-          iteratorClose(state.inner.iterator, 'normal');
-        } catch (error) {
-          return iteratorClose(iterator, 'throw', error);
+      var closeOuterIterator = function () {
+        var completion = perform(function () {
+          return getMethod(iterator, 'return');
+        });
+        returnMethod = result = completion.value;
+        if (completion.error) return Promise.reject(result);
+        if (returnMethod === undefined) return Promise.resolve(createIterResultObject(undefined, true));
+        completion = perform(function () {
+          return call(returnMethod, iterator);
+        });
+        result = completion.value;
+        if (completion.error) return Promise.reject(result);
+        return IS_ITERATOR ? Promise.resolve(result) : Promise.resolve(result).then(function (resolved) {
+          anObject(resolved);
+          return createIterResultObject(undefined, true);
+        });
+      };
+
+      var closeAndReject = function (error) {
+        return closeOuterIterator().then(function () {
+          throw error;
+        }, function () {
+          throw error;
+        });
+      };
+
+      if (inner) {
+        var innerIterator = inner.iterator;
+        var innerReturn;
+        var completion = perform(function () {
+          innerReturn = getMethod(innerIterator, 'return');
+          if (innerReturn) return call(innerReturn, innerIterator);
+        });
+        if (completion.error) return closeAndReject(completion.value);
+        if (innerReturn) {
+          return Promise.resolve(completion.value).then(function (innerResult) {
+            try {
+              anObject(innerResult);
+            } catch (error) {
+              return closeAndReject(error);
+            }
+            return closeOuterIterator();
+          }, closeAndReject);
         }
-        return getMethod(iterator, 'return');
-      });
-      returnMethod = result = completion.value;
-      if (completion.error) return Promise.reject(result);
-      if (returnMethod === undefined) return Promise.resolve(createIterResultObject(undefined, true));
-      completion = perform(function () {
-        return call(returnMethod, iterator);
-      });
-      result = completion.value;
-      if (completion.error) return Promise.reject(result);
-      return IS_ITERATOR ? Promise.resolve(result) : Promise.resolve(result).then(function (resolved) {
-        anObject(resolved);
-        return createIterResultObject(undefined, true);
-      });
+      }
+
+      return closeOuterIterator();
     }
   });
 };

package/internals/async-iterator-iteration.js

@@ -34,9 +34,11 @@ var createMethod = function (TYPE) {
 
       var loop = function () {
         try {
-          if (MAPPING) try {
+          try {
             doesNotExceedSafeInteger(counter);
-          } catch (error5) { ifAbruptCloseAsyncIterator(error5); }
+          } catch (error5) {
+            return ifAbruptCloseAsyncIterator(error5);
+          }
           Promise.resolve(anObject(call(next, iterator))).then(function (step) {
             try {
               if (anObject(step).done) {
@@ -48,7 +50,8 @@ var createMethod = function (TYPE) {
                 var value = step.value;
                 try {
                   if (MAPPING) {
-                    var result = fn(value, counter);
+                    var index = counter++;
+                    var result = fn(value, index);
 
                     var handler = function ($result) {
                       if (IS_FOR_EACH) {
@@ -57,7 +60,7 @@ var createMethod = function (TYPE) {
                         $result ? loop() : closeAsyncIteration(iterator, resolve, false, reject);
                       } else if (IS_TO_ARRAY) {
                         try {
-                          createProperty(target, counter++, $result);
+                          createProperty(target, index, $result);
                           loop();
                         } catch (error4) { ifAbruptCloseAsyncIterator(error4); }
                       } else {

package/internals/async-iterator-map.js

@@ -23,26 +23,28 @@ var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise) {
       closeAsyncIteration(iterator, doneAndReject, error, doneAndReject);
     };
 
-    Promise.resolve(anObject(call(state.next, iterator))).then(function (step) {
-      try {
-        if (anObject(step).done) {
-          state.done = true;
-          resolve(createIterResultObject(undefined, true));
-        } else {
-          var value = step.value;
-          try {
-            var result = mapper(value, state.counter++);
+    try {
+      Promise.resolve(anObject(call(state.next, iterator))).then(function (step) {
+        try {
+          if (anObject(step).done) {
+            state.done = true;
+            resolve(createIterResultObject(undefined, true));
+          } else {
+            var value = step.value;
+            try {
+              var result = mapper(value, state.counter++);
 
-            var handler = function (mapped) {
-              resolve(createIterResultObject(mapped, false));
-            };
+              var handler = function (mapped) {
+                resolve(createIterResultObject(mapped, false));
+              };
 
-            if (isObject(result)) Promise.resolve(result).then(handler, ifAbruptCloseAsyncIterator);
-            else handler(result);
-          } catch (error2) { ifAbruptCloseAsyncIterator(error2); }
-        }
-      } catch (error) { doneAndReject(error); }
-    }, doneAndReject);
+              if (isObject(result)) Promise.resolve(result).then(handler, ifAbruptCloseAsyncIterator);
+              else handler(result);
+            } catch (error2) { ifAbruptCloseAsyncIterator(error2); }
+          }
+        } catch (error) { doneAndReject(error); }
+      }, doneAndReject);
+    } catch (error) { doneAndReject(error); }
   });
 });
 

package/internals/does-not-exceed-safe-integer.js

@@ -3,6 +3,6 @@ var $TypeError = TypeError;
 var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
 
 module.exports = function (it) {
-  if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');
+  if (it > MAX_SAFE_INTEGER) throw new $TypeError('Maximum allowed index exceeded');
   return it;
 };

package/internals/environment-is-ios.js

@@ -1,5 +1,4 @@
 'use strict';
 var userAgent = require('../internals/environment-user-agent');
 
-// eslint-disable-next-line redos/no-vulnerable -- safe
-module.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);
+module.exports = /ipad|iphone|ipod/i.test(userAgent) && /applewebkit/i.test(userAgent);

package/internals/error-stack-clear.js

@@ -5,7 +5,7 @@ var $Error = Error;
 var replace = uncurryThis(''.replace);
 
 var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd');
-// eslint-disable-next-line redos/no-vulnerable, sonarjs/slow-regex -- safe
+// eslint-disable-next-line redos/no-vulnerable -- safe
 var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
 var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
 

package/internals/function-bind-native.js

@@ -3,7 +3,7 @@ var fails = require('../internals/fails');
 
 module.exports = !fails(function () {
   // eslint-disable-next-line es/no-function-prototype-bind -- safe
-  var test = (function () { /* empty */ }).bind();
+  var test = function () { /* empty */ }.bind();
   // eslint-disable-next-line no-prototype-builtins -- safe
   return typeof test != 'function' || test.hasOwnProperty('prototype');
 });

package/internals/function-name.js

@@ -8,7 +8,7 @@ var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
 
 var EXISTS = hasOwn(FunctionPrototype, 'name');
 // additional protection from minified / mangled / dropped function names
-var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
+var PROPER = EXISTS && function something() { /* empty */ }.name === 'something';
 var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
 
 module.exports = {

package/internals/get-async-iterator-flattenable.js

@@ -3,7 +3,7 @@ var call = require('../internals/function-call');
 var isCallable = require('../internals/is-callable');
 var anObject = require('../internals/an-object');
 var getIteratorDirect = require('../internals/get-iterator-direct');
-var getIteratorMethod = require('../internals/get-iterator-method');
+var getIteratorMethod = require('../internals/get-iterator-method-internal');
 var getMethod = require('../internals/get-method');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 var AsyncFromSyncIterator = require('../internals/async-from-sync-iterator');

package/internals/get-async-iterator.js

@@ -2,7 +2,7 @@
 var call = require('../internals/function-call');
 var AsyncFromSyncIterator = require('../internals/async-from-sync-iterator');
 var anObject = require('../internals/an-object');
-var getIterator = require('../internals/get-iterator');
+var getIterator = require('../internals/get-iterator-internal');
 var getIteratorDirect = require('../internals/get-iterator-direct');
 var getMethod = require('../internals/get-method');
 var wellKnownSymbol = require('../internals/well-known-symbol');

package/internals/get-internal-iterator.js

@@ -0,0 +1 @@
+// empty

package/internals/get-iterator-flattenable.js

@@ -2,7 +2,7 @@
 var call = require('../internals/function-call');
 var anObject = require('../internals/an-object');
 var getIteratorDirect = require('../internals/get-iterator-direct');
-var getIteratorMethod = require('../internals/get-iterator-method');
+var getIteratorMethod = require('../internals/get-iterator-method-internal');
 
 module.exports = function (obj, stringHandling) {
   if (!stringHandling || typeof obj !== 'string') anObject(obj);

package/internals/get-iterator-internal.js

@@ -0,0 +1,14 @@
+'use strict';
+var call = require('../internals/function-call');
+var isCallable = require('../internals/is-callable');
+var anObject = require('../internals/an-object');
+var tryToString = require('../internals/try-to-string');
+var getIteratorMethod = require('../internals/get-iterator-method-internal');
+
+var $TypeError = TypeError;
+
+module.exports = function (argument, usingIterator) {
+  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
+  if (isCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
+  throw new $TypeError(tryToString(argument) + ' is not iterable');
+};

package/internals/get-iterator-method-internal.js

@@ -0,0 +1,14 @@
+'use strict';
+var classof = require('../internals/classof-raw');
+var isNullOrUndefined = require('../internals/is-null-or-undefined');
+var getMethod = require('../internals/get-method');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+
+var ITERATOR = wellKnownSymbol('iterator');
+var ArrayPrototype = Array.prototype;
+
+module.exports = function (it) {
+  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
+    || getMethod(it, '@@iterator')
+    || (classof(it) === 'Arguments' ? ArrayPrototype[ITERATOR] : undefined);
+};

package/internals/get-iterator-method.js

@@ -1,14 +1,11 @@
 'use strict';
-var classof = require('../internals/classof');
-var getMethod = require('../internals/get-method');
-var isNullOrUndefined = require('../internals/is-null-or-undefined');
-var Iterators = require('../internals/iterators');
+var classof = require('../internals/classof-raw');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 
 var ITERATOR = wellKnownSymbol('iterator');
+var ArrayPrototype = Array.prototype;
 
 module.exports = function (it) {
-  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
-    || getMethod(it, '@@iterator')
-    || Iterators[classof(it)];
+  return it[ITERATOR] || it['@@iterator']
+    || (classof(it) === 'Arguments' ? ArrayPrototype[ITERATOR] : undefined);
 };

package/internals/get-iterator-record.js

@@ -1,5 +1,5 @@
 'use strict';
-var getIterator = require('../internals/get-iterator');
+var getIterator = require('../internals/get-iterator-internal');
 var getIteratorDirect = require('../internals/get-iterator-direct');
 
 module.exports = function (argument) {

package/internals/get-iterator.js

@@ -1,14 +1,13 @@
 'use strict';
 var call = require('../internals/function-call');
-var aCallable = require('../internals/a-callable');
-var anObject = require('../internals/an-object');
+var isCallable = require('../internals/is-callable');
 var tryToString = require('../internals/try-to-string');
 var getIteratorMethod = require('../internals/get-iterator-method');
 
 var $TypeError = TypeError;
 
-module.exports = function (argument, usingIterator) {
-  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
-  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
+module.exports = function (argument) {
+  var iteratorMethod = getIteratorMethod(argument);
+  if (isCallable(iteratorMethod)) return call(iteratorMethod, argument);
   throw new $TypeError(tryToString(argument) + ' is not iterable');
 };

package/internals/is-iterable.js

@@ -1,17 +1,11 @@
 'use strict';
-var classof = require('../internals/classof');
-var hasOwn = require('../internals/has-own-property');
-var isNullOrUndefined = require('../internals/is-null-or-undefined');
+var classof = require('../internals/classof-raw');
 var wellKnownSymbol = require('../internals/well-known-symbol');
-var Iterators = require('../internals/iterators');
 
 var ITERATOR = wellKnownSymbol('iterator');
-var $Object = Object;
 
 module.exports = function (it) {
-  if (isNullOrUndefined(it)) return false;
-  var O = $Object(it);
-  return O[ITERATOR] !== undefined
-    || '@@iterator' in O
-    || hasOwn(Iterators, classof(O));
+  return it[ITERATOR] !== undefined
+    || it['@@iterator'] !== undefined
+    || classof(it) === 'Arguments';
 };

package/internals/iterate.js

@@ -6,8 +6,8 @@ var tryToString = require('../internals/try-to-string');
 var isArrayIteratorMethod = require('../internals/is-array-iterator-method');
 var lengthOfArrayLike = require('../internals/length-of-array-like');
 var isPrototypeOf = require('../internals/object-is-prototype-of');
-var getIterator = require('../internals/get-iterator');
-var getIteratorMethod = require('../internals/get-iterator-method');
+var getIterator = require('../internals/get-iterator-internal');
+var getIteratorMethod = require('../internals/get-iterator-method-internal');
 var iteratorClose = require('../internals/iterator-close');
 
 var $TypeError = TypeError;
@@ -29,7 +29,9 @@ module.exports = function (iterable, unboundFunction, options) {
   var iterator, iterFn, index, length, result, next, step;
 
   var stop = function (condition) {
-    if (iterator) iteratorClose(iterator, 'normal');
+    var $iterator = iterator;
+    iterator = undefined;
+    if ($iterator) iteratorClose($iterator, 'normal');
     return new Result(true, condition);
   };
 
@@ -59,10 +61,13 @@ module.exports = function (iterable, unboundFunction, options) {
 
   next = IS_RECORD ? iterable.next : iterator.next;
   while (!(step = call(next, iterator)).done) {
+    // `IteratorValue` errors should propagate without closing the iterator
+    var value = step.value;
     try {
-      result = callFn(step.value);
+      result = callFn(value);
     } catch (error) {
-      iteratorClose(iterator, 'throw', error);
+      if (iterator) iteratorClose(iterator, 'throw', error);
+      else throw error;
     }
     if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
   } return new Result(false);

package/internals/iterator-chunk-size-validation.js

@@ -0,0 +1,17 @@
+'use strict';
+var isIntegralNumber = require('../internals/is-integral-number');
+var iteratorClose = require('../internals/iterator-close');
+
+var $RangeError = RangeError;
+var $TypeError = TypeError;
+
+var CHUNK_SIZE_VALIDATION_ERROR = 'Chunk size must be an integer in [1, 2^32-1]';
+
+module.exports = function (chunkSize, iterator) {
+  if (typeof chunkSize != 'number' || !isIntegralNumber(chunkSize)) {
+    return iteratorClose(iterator, 'throw', new $TypeError(CHUNK_SIZE_VALIDATION_ERROR));
+  }
+  if (chunkSize === 0 || chunkSize >>> 0 !== chunkSize) {
+    return iteratorClose(iterator, 'throw', new $RangeError(CHUNK_SIZE_VALIDATION_ERROR));
+  }
+};

package/internals/iterator-cleanup-state.js

@@ -0,0 +1,6 @@
+'use strict';
+// release references held by exhausted / closed iterator helpers to allow GC of the source chain
+module.exports = function (state) {
+  state.iterator = state.next = state.nextHandler = state.mapper = state.predicate = state.inner =
+    state.iterables = state.iters = state.openIters = state.padding = state.finishResults = state.buffer = null;
+};