core-js-pure 3.17.3 → 3.18.0

package/es/promise/all-settled.js

@@ -4,11 +4,12 @@ require('../../modules/es.object.to-string');
 require('../../modules/es.promise');
 require('../../modules/es.promise.all-settled');
 require('../../modules/es.string.iterator');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var Promise = path.Promise;
 var $allSettled = Promise.allSettled;
 
 module.exports = function allSettled(iterable) {
-  return $allSettled.call(typeof this === 'function' ? this : Promise, iterable);
+  return $allSettled.call(isCallable(this) ? this : Promise, iterable);
 };

package/es/promise/any.js

@@ -5,11 +5,12 @@ require('../../modules/es.object.to-string');
 require('../../modules/es.promise');
 require('../../modules/es.promise.any');
 require('../../modules/es.string.iterator');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var Promise = path.Promise;
 var $any = Promise.any;
 
 module.exports = function any(iterable) {
-  return $any.call(typeof this === 'function' ? this : Promise, iterable);
+  return $any.call(isCallable(this) ? this : Promise, iterable);
 };

package/features/array/from-async.js

@@ -0,0 +1,8 @@
+require('../../modules/es.array.iterator');
+require('../../modules/es.object.to-string');
+require('../../modules/es.promise');
+require('../../modules/es.string.iterator');
+require('../../modules/esnext.array.from-async');
+var path = require('../../internals/path');
+
+module.exports = path.Array.fromAsync;

package/features/array/index.js

@@ -1,5 +1,7 @@
 var parent = require('../../stable/array');
 require('../../modules/es.map');
+require('../../modules/es.promise');
+require('../../modules/esnext.array.from-async');
 // TODO: Remove from `core-js@4`
 require('../../modules/esnext.array.at');
 // TODO: Remove from `core-js@4`

package/features/index.js

@@ -221,6 +221,7 @@ require('../modules/es.unescape');
 require('../modules/es.weak-map');
 require('../modules/es.weak-set');
 require('../modules/esnext.aggregate-error');
+require('../modules/esnext.array.from-async');
 require('../modules/esnext.array.at');
 require('../modules/esnext.array.filter-out');
 require('../modules/esnext.array.filter-reject');
@@ -344,6 +345,7 @@ require('../modules/esnext.symbol.metadata');
 require('../modules/esnext.symbol.observable');
 require('../modules/esnext.symbol.pattern-match');
 require('../modules/esnext.symbol.replace-all');
+require('../modules/esnext.typed-array.from-async');
 require('../modules/esnext.typed-array.at');
 require('../modules/esnext.typed-array.filter-out');
 require('../modules/esnext.typed-array.filter-reject');

package/features/map/from.js

@@ -4,11 +4,12 @@ require('../../modules/es.map');
 require('../../modules/es.string.iterator');
 require('../../modules/esnext.map.from');
 require('../../modules/web.dom-collections.iterator');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var Map = path.Map;
 var mapFrom = Map.from;
 
 module.exports = function from(source, mapFn, thisArg) {
-  return mapFrom.call(typeof this === 'function' ? this : Map, source, mapFn, thisArg);
+  return mapFrom.call(isCallable(this) ? this : Map, source, mapFn, thisArg);
 };

package/features/map/group-by.js

@@ -1,11 +1,12 @@
 'use strict';
 require('../../modules/es.map');
 require('../../modules/esnext.map.group-by');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var Map = path.Map;
 var mapGroupBy = Map.groupBy;
 
 module.exports = function groupBy(source, iterable, keyDerivative) {
-  return mapGroupBy.call(typeof this === 'function' ? this : Map, source, iterable, keyDerivative);
+  return mapGroupBy.call(isCallable(this) ? this : Map, source, iterable, keyDerivative);
 };

package/features/map/key-by.js

@@ -1,11 +1,12 @@
 'use strict';
 require('../../modules/es.map');
 require('../../modules/esnext.map.key-by');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var Map = path.Map;
 var mapKeyBy = Map.keyBy;
 
 module.exports = function keyBy(source, iterable, keyDerivative) {
-  return mapKeyBy.call(typeof this === 'function' ? this : Map, source, iterable, keyDerivative);
+  return mapKeyBy.call(isCallable(this) ? this : Map, source, iterable, keyDerivative);
 };

package/features/map/of.js

@@ -2,11 +2,12 @@
 require('../../modules/es.array.iterator');
 require('../../modules/es.map');
 require('../../modules/esnext.map.of');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var Map = path.Map;
 var mapOf = Map.of;
 
 module.exports = function of() {
-  return mapOf.apply(typeof this === 'function' ? this : Map, arguments);
+  return mapOf.apply(isCallable(this) ? this : Map, arguments);
 };

package/features/promise/try.js

@@ -1,11 +1,12 @@
 'use strict';
 require('../../modules/es.promise');
 require('../../modules/esnext.promise.try');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var Promise = path.Promise;
 var promiseTry = Promise['try'];
 
 module.exports = { 'try': function (callbackfn) {
-  return promiseTry.call(typeof this === 'function' ? this : Promise, callbackfn);
+  return promiseTry.call(isCallable(this) ? this : Promise, callbackfn);
 } }['try'];

package/features/set/from.js

@@ -4,11 +4,12 @@ require('../../modules/es.set');
 require('../../modules/es.string.iterator');
 require('../../modules/esnext.set.from');
 require('../../modules/web.dom-collections.iterator');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var Set = path.Set;
 var setFrom = Set.from;
 
 module.exports = function from(source, mapFn, thisArg) {
-  return setFrom.call(typeof this === 'function' ? this : Set, source, mapFn, thisArg);
+  return setFrom.call(isCallable(this) ? this : Set, source, mapFn, thisArg);
 };

package/features/set/of.js

@@ -2,11 +2,12 @@
 require('../../modules/es.array.iterator');
 require('../../modules/es.set');
 require('../../modules/esnext.set.of');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var Set = path.Set;
 var setOf = Set.of;
 
 module.exports = function of() {
-  return setOf.apply(typeof this === 'function' ? this : Set, arguments);
+  return setOf.apply(isCallable(this) ? this : Set, arguments);
 };

package/features/typed-array/from-async.js

@@ -0,0 +1 @@
+require('../../modules/esnext.typed-array.from-async');

package/features/typed-array/index.js

@@ -1,5 +1,7 @@
 var parent = require('../../stable/typed-array');
 require('../../modules/es.map');
+require('../../modules/es.promise');
+require('../../modules/esnext.typed-array.from-async');
 // TODO: Remove from `core-js@4`
 require('../../modules/esnext.typed-array.at');
 // TODO: Remove from `core-js@4`

package/features/weak-map/from.js

@@ -4,11 +4,12 @@ require('../../modules/es.string.iterator');
 require('../../modules/es.weak-map');
 require('../../modules/esnext.weak-map.from');
 require('../../modules/web.dom-collections.iterator');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var WeakMap = path.WeakMap;
 var weakMapFrom = WeakMap.from;
 
 module.exports = function from(source, mapFn, thisArg) {
-  return weakMapFrom.call(typeof this === 'function' ? this : WeakMap, source, mapFn, thisArg);
+  return weakMapFrom.call(isCallable(this) ? this : WeakMap, source, mapFn, thisArg);
 };

package/features/weak-map/of.js

@@ -2,11 +2,12 @@
 require('../../modules/es.array.iterator');
 require('../../modules/es.weak-map');
 require('../../modules/esnext.weak-map.of');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var WeakMap = path.WeakMap;
 var weakMapOf = WeakMap.of;
 
 module.exports = function of() {
-  return weakMapOf.apply(typeof this === 'function' ? this : WeakMap, arguments);
+  return weakMapOf.apply(isCallable(this) ? this : WeakMap, arguments);
 };

package/features/weak-set/from.js

@@ -4,11 +4,12 @@ require('../../modules/es.string.iterator');
 require('../../modules/es.weak-set');
 require('../../modules/esnext.weak-set.from');
 require('../../modules/web.dom-collections.iterator');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var WeakSet = path.WeakSet;
 var weakSetfrom = WeakSet.from;
 
 module.exports = function from(source, mapFn, thisArg) {
-  return weakSetfrom.call(typeof this === 'function' ? this : WeakSet, source, mapFn, thisArg);
+  return weakSetfrom.call(isCallable(this) ? this : WeakSet, source, mapFn, thisArg);
 };

package/features/weak-set/of.js

@@ -2,11 +2,12 @@
 require('../../modules/es.array.iterator');
 require('../../modules/es.weak-set');
 require('../../modules/esnext.weak-set.of');
+var isCallable = require('../../internals/is-callable');
 var path = require('../../internals/path');
 
 var WeakSet = path.WeakSet;
 var weakSetOf = WeakSet.of;
 
 module.exports = function of() {
-  return weakSetOf.apply(typeof this === 'function' ? this : WeakSet, arguments);
+  return weakSetOf.apply(isCallable(this) ? this : WeakSet, arguments);
 };

package/internals/a-callable.js

@@ -0,0 +1,8 @@
+var isCallable = require('../internals/is-callable');
+var tryToString = require('../internals/try-to-string');
+
+// `Assert: IsCallable(argument) is true`
+module.exports = function (argument) {
+  if (isCallable(argument)) return argument;
+  throw TypeError(tryToString(argument) + ' is not a function');
+};

package/internals/a-constructor.js

@@ -0,0 +1,8 @@
+var isConstructor = require('../internals/is-constructor');
+var tryToString = require('../internals/try-to-string');
+
+// `Assert: IsConstructor(argument) is true`
+module.exports = function (argument) {
+  if (isConstructor(argument)) return argument;
+  throw TypeError(tryToString(argument) + ' is not a constructor');
+};

package/internals/a-possible-prototype.js

@@ -1,7 +1,6 @@
-var isObject = require('../internals/is-object');
+var isCallable = require('../internals/is-callable');
 
-module.exports = function (it) {
-  if (!isObject(it) && it !== null) {
-    throw TypeError("Can't set " + String(it) + ' as a prototype');
-  } return it;
+module.exports = function (argument) {
+  if (typeof argument === 'object' || isCallable(argument)) return argument;
+  throw TypeError("Can't set " + String(argument) + ' as a prototype');
 };

package/internals/an-instance.js

@@ -1,5 +1,4 @@
 module.exports = function (it, Constructor, name) {
-  if (!(it instanceof Constructor)) {
-    throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
-  } return it;
+  if (it instanceof Constructor) return it;
+  throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
 };

package/internals/an-object.js

@@ -1,7 +1,7 @@
 var isObject = require('../internals/is-object');
 
-module.exports = function (it) {
-  if (!isObject(it)) {
-    throw TypeError(String(it) + ' is not an object');
-  } return it;
+// `Assert: Type(argument) is Object`
+module.exports = function (argument) {
+  if (isObject(argument)) return argument;
+  throw TypeError(String(argument) + ' is not an object');
 };

package/internals/array-from-async.js

@@ -0,0 +1,32 @@
+'use strict';
+var bind = require('../internals/function-bind-context');
+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 getIteratorMethod = require('../internals/get-iterator-method');
+var getMethod = require('../internals/get-method');
+var getVirtual = require('../internals/entry-virtual');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var AsyncFromSyncIterator = require('../internals/async-from-sync-iterator');
+var toArray = require('../internals/async-iterator-iteration').toArray;
+
+var ASYNC_ITERATOR = wellKnownSymbol('asyncIterator');
+var arrayIterator = getVirtual('Array').values;
+
+// `Array.fromAsync` method implementation
+// https://github.com/tc39/proposal-array-from-async
+module.exports = function fromAsync(asyncItems /* , mapfn = undefined, thisArg = undefined */) {
+  var O = toObject(asyncItems);
+  var argumentsLength = arguments.length;
+  var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
+  if (mapfn !== undefined) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2);
+  var usingAsyncIterator = getMethod(O, ASYNC_ITERATOR);
+  var usingIterator;
+  if (!usingAsyncIterator) usingIterator = getIteratorMethod(O);
+  var A = isConstructor(this) ? new this() : [];
+  var iterator = usingAsyncIterator
+    ? getAsyncIterator(O, usingAsyncIterator)
+    : new AsyncFromSyncIterator(getIterator(O, usingIterator || arrayIterator));
+  return toArray(iterator, mapfn, A);
+};

package/internals/array-from.js

@@ -3,6 +3,7 @@ var bind = require('../internals/function-bind-context');
 var toObject = require('../internals/to-object');
 var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');
 var isArrayIteratorMethod = require('../internals/is-array-iterator-method');
+var isConstructor = require('../internals/is-constructor');
 var toLength = require('../internals/to-length');
 var createProperty = require('../internals/create-property');
 var getIterator = require('../internals/get-iterator');
@@ -12,26 +13,26 @@ var getIteratorMethod = require('../internals/get-iterator-method');
 // https://tc39.es/ecma262/#sec-array.from
 module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
   var O = toObject(arrayLike);
-  var C = typeof this == 'function' ? this : Array;
+  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, 2);
   var iteratorMethod = getIteratorMethod(O);
   var index = 0;
   var length, result, step, iterator, next, value;
-  if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2);
   // if the target is not iterable or it's an array with the default iterator - use a simple case
-  if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) {
+  if (iteratorMethod && !(this == Array && isArrayIteratorMethod(iteratorMethod))) {
     iterator = getIterator(O, iteratorMethod);
     next = iterator.next;
-    result = new C();
+    result = IS_CONSTRUCTOR ? new this() : [];
     for (;!(step = next.call(iterator)).done; index++) {
       value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
       createProperty(result, index, value);
     }
   } else {
     length = toLength(O.length);
-    result = new C(length);
+    result = IS_CONSTRUCTOR ? new this(length) : Array(length);
     for (;length > index; index++) {
       value = mapping ? mapfn(O[index], index) : O[index];
       createProperty(result, index, value);

package/internals/array-reduce.js

@@ -1,4 +1,4 @@
-var aFunction = require('../internals/a-function');
+var aCallable = require('../internals/a-callable');
 var toObject = require('../internals/to-object');
 var IndexedObject = require('../internals/indexed-object');
 var toLength = require('../internals/to-length');
@@ -6,7 +6,7 @@ var toLength = require('../internals/to-length');
 // `Array.prototype.{ reduce, reduceRight }` methods implementation
 var createMethod = function (IS_RIGHT) {
   return function (that, callbackfn, argumentsLength, memo) {
-    aFunction(callbackfn);
+    aCallable(callbackfn);
     var O = toObject(that);
     var self = IndexedObject(O);
     var length = toLength(O.length);

package/internals/array-species-constructor.js

@@ -1,5 +1,6 @@
-var isObject = require('../internals/is-object');
 var isArray = require('../internals/is-array');
+var isConstructor = require('../internals/is-constructor');
+var isObject = require('../internals/is-object');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 
 var SPECIES = wellKnownSymbol('species');
@@ -11,7 +12,7 @@ module.exports = function (originalArray) {
   if (isArray(originalArray)) {
     C = originalArray.constructor;
     // cross-realm fallback
-    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
+    if (isConstructor(C) && (C === Array || isArray(C.prototype))) C = undefined;
     else if (isObject(C)) {
       C = C[SPECIES];
       if (C === null) C = undefined;

package/internals/array-unique-by.js

@@ -1,4 +1,5 @@
 'use strict';
+var aCallable = require('../internals/a-callable');
 var toLength = require('../internals/to-length');
 var toObject = require('../internals/to-object');
 var getBuiltIn = require('../internals/get-built-in');
@@ -15,11 +16,10 @@ module.exports = function uniqueBy(resolver) {
   var Map = getBuiltIn('Map');
   var map = new Map();
   var resolverFunction, index, item, key;
-  if (typeof resolver == 'function') resolverFunction = resolver;
-  else if (resolver == null) resolverFunction = function (value) {
+  if (resolver != null) resolverFunction = aCallable(resolver);
+  else resolverFunction = function (value) {
     return value;
   };
-  else throw new TypeError('Incorrect resolver!');
   for (index = 0; index < length; index++) {
     item = that[index];
     key = resolverFunction(item);

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

@@ -39,7 +39,7 @@ AsyncFromSyncIterator.prototype = redefineAll(create(AsyncIteratorPrototype), {
     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(AsyncIteratorPrototype), {
     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,5 +1,5 @@
 'use strict';
-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');
@@ -7,6 +7,7 @@ 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,7 +19,7 @@ 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);
@@ -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,30 @@
 'use strict';
 // https://github.com/tc39/proposal-iterator-helpers
-var aFunction = require('../internals/a-function');
+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 +42,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 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');
 
@@ -14,7 +15,7 @@ var AsyncIteratorPrototype, prototype;
 
 if (PassedAsyncIteratorPrototype) {
   AsyncIteratorPrototype = PassedAsyncIteratorPrototype;
-} else if (typeof AsyncIterator == 'function') {
+} else if (isCallable(AsyncIterator)) {
   AsyncIteratorPrototype = AsyncIterator.prototype;
 } else if (shared[USE_FUNCTION_CONSTRUCTOR] || global[USE_FUNCTION_CONSTRUCTOR]) {
   try {
@@ -27,8 +28,8 @@ if (PassedAsyncIteratorPrototype) {
 if (!AsyncIteratorPrototype) AsyncIteratorPrototype = {};
 else if (IS_PURE) AsyncIteratorPrototype = create(AsyncIteratorPrototype);
 
-if (typeof AsyncIteratorPrototype[ASYNC_ITERATOR] !== 'function') {
-  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]);
   }