core-js-pure 3.17.2 → 3.18.2

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

@@ -1,11 +1,11 @@
 'use strict';
-var path = require('../internals/path');
 var anObject = require('../internals/an-object');
 var create = require('../internals/object-create');
 var getMethod = require('../internals/get-method');
 var redefineAll = require('../internals/redefine-all');
 var InternalStateModule = require('../internals/internal-state');
 var getBuiltIn = require('../internals/get-built-in');
+var AsyncIteratorPrototype = require('../internals/async-iterator-prototype');
 
 var Promise = getBuiltIn('Promise');
 
@@ -26,7 +26,7 @@ var AsyncFromSyncIterator = function AsyncIterator(iterator) {
   });
 };
 
-AsyncFromSyncIterator.prototype = redefineAll(create(path.AsyncIterator.prototype), {
+AsyncFromSyncIterator.prototype = redefineAll(create(AsyncIteratorPrototype), {
   next: function next(arg) {
     var state = getInternalState(this);
     var hasArg = !!arguments.length;
@@ -39,7 +39,7 @@ AsyncFromSyncIterator.prototype = redefineAll(create(path.AsyncIterator.prototyp
     var iterator = getInternalState(this).iterator;
     var hasArg = !!arguments.length;
     return new Promise(function (resolve, reject) {
-      var $return = getMethod(iterator['return']);
+      var $return = getMethod(iterator, 'return');
       if ($return === undefined) return resolve({ done: true, value: arg });
       var result = anObject($return.apply(iterator, hasArg ? [arg] : []));
       asyncFromSyncIteratorContinuation(result, resolve, reject);
@@ -49,7 +49,7 @@ AsyncFromSyncIterator.prototype = redefineAll(create(path.AsyncIterator.prototyp
     var iterator = getInternalState(this).iterator;
     var hasArg = !!arguments.length;
     return new Promise(function (resolve, reject) {
-      var $throw = getMethod(iterator['throw']);
+      var $throw = getMethod(iterator, 'throw');
       if ($throw === undefined) return reject(arg);
       var result = anObject($throw.apply(iterator, hasArg ? [arg] : []));
       asyncFromSyncIteratorContinuation(result, resolve, reject);

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

@@ -1,6 +1,5 @@
 'use strict';
-var path = require('../internals/path');
-var aFunction = require('../internals/a-function');
+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');
@@ -8,6 +7,8 @@ var redefineAll = require('../internals/redefine-all');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 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 Promise = getBuiltIn('Promise');
 
@@ -18,13 +19,13 @@ var TO_STRING_TAG = wellKnownSymbol('toStringTag');
 
 module.exports = function (nextHandler, IS_ITERATOR) {
   var AsyncIteratorProxy = function AsyncIterator(state) {
-    state.next = aFunction(state.iterator.next);
+    state.next = aCallable(state.iterator.next);
     state.done = false;
     state.ignoreArgument = !IS_ITERATOR;
     setInternalState(this, state);
   };
 
-  AsyncIteratorProxy.prototype = redefineAll(create(path.AsyncIterator.prototype), {
+  AsyncIteratorProxy.prototype = redefineAll(create(AsyncIteratorPrototype), {
     next: function next(arg) {
       var that = this;
       var hasArgument = !!arguments.length;
@@ -41,7 +42,7 @@ module.exports = function (nextHandler, IS_ITERATOR) {
         var state = getInternalState(that);
         var iterator = state.iterator;
         state.done = true;
-        var $$return = iterator['return'];
+        var $$return = getMethod(iterator, 'return');
         if ($$return === undefined) return resolve({ done: true, value: value });
         Promise.resolve($$return.call(iterator, value)).then(function (result) {
           anObject(result);
@@ -55,7 +56,7 @@ module.exports = function (nextHandler, IS_ITERATOR) {
         var state = getInternalState(that);
         var iterator = state.iterator;
         state.done = true;
-        var $$throw = iterator['throw'];
+        var $$throw = getMethod(iterator, 'throw');
         if ($$throw === undefined) return reject(value);
         resolve($$throw.call(iterator, value));
       });

package/internals/async-iterator-iteration.js

@@ -1,28 +1,31 @@
 'use strict';
 // https://github.com/tc39/proposal-iterator-helpers
-var aFunction = require('../internals/a-function');
+// https://github.com/tc39/proposal-array-from-async
+var aCallable = require('../internals/a-callable');
 var anObject = require('../internals/an-object');
 var getBuiltIn = require('../internals/get-built-in');
+var getMethod = require('../internals/get-method');
 
-var Promise = getBuiltIn('Promise');
-var push = [].push;
+var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;
 
 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) {
+  return function (iterator, fn, target) {
     anObject(iterator);
-    var next = aFunction(iterator.next);
-    var array = IS_TO_ARRAY ? [] : undefined;
-    if (!IS_TO_ARRAY) aFunction(fn);
+    var Promise = getBuiltIn('Promise');
+    var next = aCallable(iterator.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 = iterator['return'];
-          if (returnMethod !== undefined) {
+          var returnMethod = getMethod(iterator, 'return');
+          if (returnMethod) {
             return Promise.resolve(returnMethod.call(iterator)).then(function () {
               method(argument);
             }, function (error) {
@@ -40,25 +43,34 @@ var createMethod = function (TYPE) {
 
       var loop = function () {
         try {
+          if (IS_TO_ARRAY && (index > MAX_SAFE_INTEGER) && MAPPING) {
+            throw TypeError('The allowed number of iterations has been exceeded');
+          }
           Promise.resolve(anObject(next.call(iterator))).then(function (step) {
             try {
               if (anObject(step).done) {
-                resolve(IS_TO_ARRAY ? array : IS_SOME ? false : IS_EVERY || undefined);
+                if (IS_TO_ARRAY) {
+                  target.length = index;
+                  resolve(target);
+                } else resolve(IS_SOME ? false : IS_EVERY || undefined);
               } else {
                 var value = step.value;
-                if (IS_TO_ARRAY) {
-                  push.call(array, value);
-                  loop();
-                } else {
-                  Promise.resolve(fn(value)).then(function (result) {
+                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();
                 }
               }
             } catch (error) { onError(error); }

package/internals/async-iterator-prototype.js

@@ -1,8 +1,9 @@
 var global = require('../internals/global');
 var shared = require('../internals/shared-store');
+var isCallable = require('../internals/is-callable');
+var create = require('../internals/object-create');
 var getPrototypeOf = require('../internals/object-get-prototype-of');
-var has = require('../internals/has');
-var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var redefine = require('../internals/redefine');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 var IS_PURE = require('../internals/is-pure');
 
@@ -12,24 +13,23 @@ var AsyncIterator = global.AsyncIterator;
 var PassedAsyncIteratorPrototype = shared.AsyncIteratorPrototype;
 var AsyncIteratorPrototype, prototype;
 
-if (!IS_PURE) {
-  if (PassedAsyncIteratorPrototype) {
-    AsyncIteratorPrototype = PassedAsyncIteratorPrototype;
-  } else if (typeof AsyncIterator == 'function') {
-    AsyncIteratorPrototype = AsyncIterator.prototype;
-  } else if (shared[USE_FUNCTION_CONSTRUCTOR] || global[USE_FUNCTION_CONSTRUCTOR]) {
-    try {
-      // eslint-disable-next-line no-new-func -- we have no alternatives without usage of modern syntax
-      prototype = getPrototypeOf(getPrototypeOf(getPrototypeOf(Function('return async function*(){}()')())));
-      if (getPrototypeOf(prototype) === Object.prototype) AsyncIteratorPrototype = prototype;
-    } catch (error) { /* empty */ }
-  }
+if (PassedAsyncIteratorPrototype) {
+  AsyncIteratorPrototype = PassedAsyncIteratorPrototype;
+} else if (isCallable(AsyncIterator)) {
+  AsyncIteratorPrototype = AsyncIterator.prototype;
+} else if (shared[USE_FUNCTION_CONSTRUCTOR] || global[USE_FUNCTION_CONSTRUCTOR]) {
+  try {
+    // eslint-disable-next-line no-new-func -- we have no alternatives without usage of modern syntax
+    prototype = getPrototypeOf(getPrototypeOf(getPrototypeOf(Function('return async function*(){}()')())));
+    if (getPrototypeOf(prototype) === Object.prototype) AsyncIteratorPrototype = prototype;
+  } catch (error) { /* empty */ }
 }
 
 if (!AsyncIteratorPrototype) AsyncIteratorPrototype = {};
+else if (IS_PURE) AsyncIteratorPrototype = create(AsyncIteratorPrototype);
 
-if (!has(AsyncIteratorPrototype, ASYNC_ITERATOR)) {
-  createNonEnumerableProperty(AsyncIteratorPrototype, ASYNC_ITERATOR, function () {
+if (!isCallable(AsyncIteratorPrototype[ASYNC_ITERATOR])) {
+  redefine(AsyncIteratorPrototype, ASYNC_ITERATOR, function () {
     return this;
   });
 }

package/internals/classof.js

@@ -1,4 +1,5 @@
 var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');
+var isCallable = require('../internals/is-callable');
 var classofRaw = require('../internals/classof-raw');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 
@@ -22,5 +23,5 @@ module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
     // builtinTag case
     : CORRECT_ARGUMENTS ? classofRaw(O)
     // ES3 arguments fallback
-    : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
+    : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
 };

package/internals/collection-add-all.js

@@ -1,11 +1,11 @@
 'use strict';
+var aCallable = require('../internals/a-callable');
 var anObject = require('../internals/an-object');
-var aFunction = require('../internals/a-function');
 
 // https://github.com/tc39/collection-methods
 module.exports = function (/* ...elements */) {
   var set = anObject(this);
-  var adder = aFunction(set.add);
+  var adder = aCallable(set.add);
   for (var k = 0, len = arguments.length; k < len; k++) {
     adder.call(set, arguments[k]);
   }

package/internals/collection-delete-all.js

@@ -1,11 +1,11 @@
 'use strict';
+var aCallable = require('../internals/a-callable');
 var anObject = require('../internals/an-object');
-var aFunction = require('../internals/a-function');
 
 // https://github.com/tc39/collection-methods
 module.exports = function (/* ...elements */) {
   var collection = anObject(this);
-  var remover = aFunction(collection['delete']);
+  var remover = aCallable(collection['delete']);
   var allDeleted = true;
   var wasDeleted;
   for (var k = 0, len = arguments.length; k < len; k++) {

package/internals/collection-from.js

@@ -1,6 +1,7 @@
 'use strict';
 // https://tc39.github.io/proposal-setmap-offrom/
-var aFunction = require('../internals/a-function');
+var aCallable = require('../internals/a-callable');
+var aConstructor = require('../internals/a-constructor');
 var bind = require('../internals/function-bind-context');
 var iterate = require('../internals/iterate');
 
@@ -8,9 +9,9 @@ module.exports = function from(source /* , mapFn, thisArg */) {
   var length = arguments.length;
   var mapFn = length > 1 ? arguments[1] : undefined;
   var mapping, array, n, boundFunction;
-  aFunction(this);
+  aConstructor(this);
   mapping = mapFn !== undefined;
-  if (mapping) aFunction(mapFn);
+  if (mapping) aCallable(mapFn);
   if (source == undefined) return new this();
   array = [];
   if (mapping) {

package/internals/collection-weak.js

@@ -6,7 +6,7 @@ var isObject = require('../internals/is-object');
 var anInstance = require('../internals/an-instance');
 var iterate = require('../internals/iterate');
 var ArrayIterationModule = require('../internals/array-iteration');
-var $has = require('../internals/has');
+var hasOwn = require('../internals/has-own-property');
 var InternalStateModule = require('../internals/internal-state');
 
 var setInternalState = InternalStateModule.set;
@@ -83,7 +83,7 @@ module.exports = {
         if (!isObject(key)) return false;
         var data = getWeakData(key);
         if (data === true) return uncaughtFrozenStore(state)['delete'](key);
-        return data && $has(data, state.id) && delete data[state.id];
+        return data && hasOwn(data, state.id) && delete data[state.id];
       },
       // `{ WeakMap, WeakSet }.prototype.has(key)` methods
       // https://tc39.es/ecma262/#sec-weakmap.prototype.has
@@ -93,7 +93,7 @@ module.exports = {
         if (!isObject(key)) return false;
         var data = getWeakData(key);
         if (data === true) return uncaughtFrozenStore(state).has(key);
-        return data && $has(data, state.id);
+        return data && hasOwn(data, state.id);
       }
     });
 

package/internals/collection.js

@@ -1,11 +1,12 @@
 'use strict';
-var $ = require('./export');
+var $ = require('../internals/export');
 var global = require('../internals/global');
 var InternalMetadataModule = require('../internals/internal-metadata');
 var fails = require('../internals/fails');
 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
 var iterate = require('../internals/iterate');
 var anInstance = require('../internals/an-instance');
+var isCallable = require('../internals/is-callable');
 var isObject = require('../internals/is-object');
 var setToStringTag = require('../internals/set-to-string-tag');
 var defineProperty = require('../internals/object-define-property').f;
@@ -25,7 +26,7 @@ module.exports = function (CONSTRUCTOR_NAME, wrapper, common) {
   var exported = {};
   var Constructor;
 
-  if (!DESCRIPTORS || typeof NativeConstructor != 'function'
+  if (!DESCRIPTORS || !isCallable(NativeConstructor)
     || !(IS_WEAK || NativePrototype.forEach && !fails(function () { new NativeConstructor().entries().next(); }))
   ) {
     // create collection constructor

package/internals/copy-constructor-properties.js

@@ -1,4 +1,4 @@
-var has = require('../internals/has');
+var hasOwn = require('../internals/has-own-property');
 var ownKeys = require('../internals/own-keys');
 var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
 var definePropertyModule = require('../internals/object-define-property');
@@ -9,6 +9,6 @@ module.exports = function (target, source) {
   var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
   for (var i = 0; i < keys.length; i++) {
     var key = keys[i];
-    if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+    if (!hasOwn(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
   }
 };

package/internals/define-iterator.js

@@ -1,5 +1,8 @@
 'use strict';
 var $ = require('../internals/export');
+var IS_PURE = require('../internals/is-pure');
+var FunctionName = require('../internals/function-name');
+var isCallable = require('../internals/is-callable');
 var createIteratorConstructor = require('../internals/create-iterator-constructor');
 var getPrototypeOf = require('../internals/object-get-prototype-of');
 var setPrototypeOf = require('../internals/object-set-prototype-of');
@@ -7,10 +10,11 @@ var setToStringTag = require('../internals/set-to-string-tag');
 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
 var redefine = require('../internals/redefine');
 var wellKnownSymbol = require('../internals/well-known-symbol');
-var IS_PURE = require('../internals/is-pure');
 var Iterators = require('../internals/iterators');
 var IteratorsCore = require('../internals/iterators-core');
 
+var PROPER_FUNCTION_NAME = FunctionName.PROPER;
+var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
 var IteratorPrototype = IteratorsCore.IteratorPrototype;
 var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
 var ITERATOR = wellKnownSymbol('iterator');
@@ -46,12 +50,12 @@ module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, I
   // fix native
   if (anyNativeIterator) {
     CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
-    if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
+    if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
       if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
         if (setPrototypeOf) {
           setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
-        } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {
-          createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);
+        } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {
+          redefine(CurrentIteratorPrototype, ITERATOR, returnThis);
         }
       }
       // Set @@toStringTag to native iterators
@@ -61,17 +65,15 @@ module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, I
   }
 
   // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
-  if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
-    INCORRECT_VALUES_NAME = true;
-    defaultIterator = function values() { return nativeIterator.call(this); };
+  if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
+    if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {
+      createNonEnumerableProperty(IterablePrototype, 'name', VALUES);
+    } else {
+      INCORRECT_VALUES_NAME = true;
+      defaultIterator = function values() { return nativeIterator.call(this); };
+    }
   }
 
-  // define iterator
-  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
-    createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);
-  }
-  Iterators[NAME] = defaultIterator;
-
   // export additional methods
   if (DEFAULT) {
     methods = {
@@ -86,5 +88,11 @@ module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, I
     } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
   }
 
+  // define iterator
+  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
+    redefine(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });
+  }
+  Iterators[NAME] = defaultIterator;
+
   return methods;
 };

package/internals/define-well-known-symbol.js

@@ -1,11 +1,11 @@
 var path = require('../internals/path');
-var has = require('../internals/has');
+var hasOwn = require('../internals/has-own-property');
 var wrappedWellKnownSymbolModule = require('../internals/well-known-symbol-wrapped');
 var defineProperty = require('../internals/object-define-property').f;
 
 module.exports = function (NAME) {
   var Symbol = path.Symbol || (path.Symbol = {});
-  if (!has(Symbol, NAME)) defineProperty(Symbol, NAME, {
+  if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, {
     value: wrappedWellKnownSymbolModule.f(NAME)
   });
 };

package/internals/dom-token-list-prototype.js

@@ -0,0 +1,7 @@
+// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
+var documentCreateElement = require('../internals/document-create-element');
+
+var classList = documentCreateElement('span').classList;
+var DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;
+
+module.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;

package/internals/export.js

@@ -1,11 +1,12 @@
 'use strict';
 var global = require('../internals/global');
+var isCallable = require('../internals/is-callable');
 var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
 var isForced = require('../internals/is-forced');
 var path = require('../internals/path');
 var bind = require('../internals/function-bind-context');
 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
-var has = require('../internals/has');
+var hasOwn = require('../internals/has-own-property');
 
 var wrapConstructor = function (NativeConstructor) {
   var Wrapper = function (a, b, c) {
@@ -34,6 +35,7 @@ var wrapConstructor = function (NativeConstructor) {
   options.sham        - add a flag to not completely full polyfills
   options.enumerable  - export as enumerable property
   options.noTargetGet - prevent calling a getter on target
+  options.name        - the .name of the function if it does not match the key
 */
 module.exports = function (options, source) {
   var TARGET = options.target;
@@ -52,7 +54,7 @@ module.exports = function (options, source) {
   for (key in source) {
     FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
     // contains in native
-    USE_NATIVE = !FORCED && nativeSource && has(nativeSource, key);
+    USE_NATIVE = !FORCED && nativeSource && hasOwn(nativeSource, key);
 
     targetProperty = target[key];
 
@@ -71,7 +73,7 @@ module.exports = function (options, source) {
     // wrap global constructors for prevent changs in this version
     else if (options.wrap && USE_NATIVE) resultProperty = wrapConstructor(sourceProperty);
     // make static versions for prototype methods
-    else if (PROTO && typeof sourceProperty == 'function') resultProperty = bind(Function.call, sourceProperty);
+    else if (PROTO && isCallable(sourceProperty)) resultProperty = bind(Function.call, sourceProperty);
     // default case
     else resultProperty = sourceProperty;
 
@@ -84,7 +86,7 @@ module.exports = function (options, source) {
 
     if (PROTO) {
       VIRTUAL_PROTOTYPE = TARGET + 'Prototype';
-      if (!has(path, VIRTUAL_PROTOTYPE)) {
+      if (!hasOwn(path, VIRTUAL_PROTOTYPE)) {
         createNonEnumerableProperty(path, VIRTUAL_PROTOTYPE, {});
       }
       // export virtual prototype methods

package/internals/flatten-into-array.js

@@ -1,6 +1,6 @@
 'use strict';
 var isArray = require('../internals/is-array');
-var toLength = require('../internals/to-length');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 var bind = require('../internals/function-bind-context');
 
 // `FlattenIntoArray` abstract operation
@@ -9,14 +9,15 @@ var flattenIntoArray = function (target, original, source, sourceLen, start, dep
   var targetIndex = start;
   var sourceIndex = 0;
   var mapFn = mapper ? bind(mapper, thisArg, 3) : false;
-  var element;
+  var element, elementLen;
 
   while (sourceIndex < sourceLen) {
     if (sourceIndex in source) {
       element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];
 
       if (depth > 0 && isArray(element)) {
-        targetIndex = flattenIntoArray(target, original, element, toLength(element.length), targetIndex, depth - 1) - 1;
+        elementLen = lengthOfArrayLike(element);
+        targetIndex = flattenIntoArray(target, original, element, elementLen, targetIndex, depth - 1) - 1;
       } else {
         if (targetIndex >= 0x1FFFFFFFFFFFFF) throw TypeError('Exceed the acceptable array length');
         target[targetIndex] = element;

package/internals/function-bind-context.js

@@ -1,8 +1,8 @@
-var aFunction = require('../internals/a-function');
+var aCallable = require('../internals/a-callable');
 
 // optional / simple context binding
 module.exports = function (fn, that, length) {
-  aFunction(fn);
+  aCallable(fn);
   if (that === undefined) return fn;
   switch (length) {
     case 0: return function () {

package/internals/function-bind.js

@@ -1,5 +1,5 @@
 'use strict';
-var aFunction = require('../internals/a-function');
+var aCallable = require('../internals/a-callable');
 var isObject = require('../internals/is-object');
 
 var slice = [].slice;
@@ -16,7 +16,7 @@ var construct = function (C, argsLength, args) {
 // `Function.prototype.bind` method implementation
 // https://tc39.es/ecma262/#sec-function.prototype.bind
 module.exports = Function.bind || function bind(that /* , ...args */) {
-  var fn = aFunction(this);
+  var fn = aCallable(this);
   var partArgs = slice.call(arguments, 1);
   var boundFunction = function bound(/* args... */) {
     var args = partArgs.concat(slice.call(arguments));

package/internals/function-name.js

@@ -0,0 +1,17 @@
+var DESCRIPTORS = require('../internals/descriptors');
+var hasOwn = require('../internals/has-own-property');
+
+var FunctionPrototype = Function.prototype;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+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 CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
+
+module.exports = {
+  EXISTS: EXISTS,
+  PROPER: PROPER,
+  CONFIGURABLE: CONFIGURABLE
+};

package/internals/get-async-iterator.js

@@ -1,5 +1,4 @@
 var AsyncFromSyncIterator = require('../internals/async-from-sync-iterator');
-var aFunction = require('../internals/a-function');
 var anObject = require('../internals/an-object');
 var getIterator = require('../internals/get-iterator');
 var getMethod = require('../internals/get-method');
@@ -8,8 +7,6 @@ var wellKnownSymbol = require('../internals/well-known-symbol');
 var ASYNC_ITERATOR = wellKnownSymbol('asyncIterator');
 
 module.exports = function (it, usingIterator) {
-  var method = arguments.length < 2 ? getMethod(it[ASYNC_ITERATOR]) : usingIterator;
-  if (method === undefined) {
-    return new AsyncFromSyncIterator(getIterator(it));
-  } return anObject(aFunction(method).call(it));
+  var method = arguments.length < 2 ? getMethod(it, ASYNC_ITERATOR) : usingIterator;
+  return method ? anObject(method.call(it)) : new AsyncFromSyncIterator(getIterator(it));
 };

package/internals/get-built-in.js

@@ -1,8 +1,9 @@
 var path = require('../internals/path');
 var global = require('../internals/global');
+var isCallable = require('../internals/is-callable');
 
 var aFunction = function (variable) {
-  return typeof variable == 'function' ? variable : undefined;
+  return isCallable(variable) ? variable : undefined;
 };
 
 module.exports = function (namespace, method) {

package/internals/get-iterator-method.js

@@ -1,11 +1,12 @@
 var classof = require('../internals/classof');
+var getMethod = require('../internals/get-method');
 var Iterators = require('../internals/iterators');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 
 var ITERATOR = wellKnownSymbol('iterator');
 
 module.exports = function (it) {
-  if (it != undefined) return it[ITERATOR]
-    || it['@@iterator']
+  if (it != undefined) return getMethod(it, ITERATOR)
+    || getMethod(it, '@@iterator')
     || Iterators[classof(it)];
 };

package/internals/get-iterator.js

@@ -1,9 +1,9 @@
+var aCallable = require('../internals/a-callable');
 var anObject = require('../internals/an-object');
 var getIteratorMethod = require('../internals/get-iterator-method');
 
-module.exports = function (it, usingIterator) {
-  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(it) : usingIterator;
-  if (typeof iteratorMethod != 'function') {
-    throw TypeError(String(it) + ' is not iterable');
-  } return anObject(iteratorMethod.call(it));
+module.exports = function (argument, usingIterator) {
+  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
+  if (aCallable(iteratorMethod)) return anObject(iteratorMethod.call(argument));
+  throw TypeError(String(argument) + ' is not iterable');
 };