core-js-pure 3.17.3 → 3.18.3

package/configurator.js

@@ -1,4 +1,4 @@
-var has = require('./internals/has');
+var hasOwn = require('./internals/has-own-property');
 var isArray = require('./internals/is-array');
 var isForced = require('./internals/is-forced');
 var shared = require('./internals/shared-store');
@@ -17,7 +17,11 @@ module.exports = function (options) {
     setAggressivenessLevel(options.useNative, isForced.NATIVE);
     setAggressivenessLevel(options.usePolyfill, isForced.POLYFILL);
     setAggressivenessLevel(options.useFeatureDetection, null);
-    if (has(options, USE_FUNCTION_CONSTRUCTOR)) shared[USE_FUNCTION_CONSTRUCTOR] = !!options[USE_FUNCTION_CONSTRUCTOR];
-    if (has(options, ASYNC_ITERATOR_PROTOTYPE)) shared[USE_FUNCTION_CONSTRUCTOR] = options[ASYNC_ITERATOR_PROTOTYPE];
+    if (hasOwn(options, USE_FUNCTION_CONSTRUCTOR)) {
+      shared[USE_FUNCTION_CONSTRUCTOR] = !!options[USE_FUNCTION_CONSTRUCTOR];
+    }
+    if (hasOwn(options, ASYNC_ITERATOR_PROTOTYPE)) {
+      shared[USE_FUNCTION_CONSTRUCTOR] = options[ASYNC_ITERATOR_PROTOTYPE];
+    }
   }
 };

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/typed-array/methods.js

@@ -1,5 +1,7 @@
 var parent = require('../../stable/typed-array/methods');
 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-copy-within.js

@@ -1,7 +1,7 @@
 'use strict';
 var toObject = require('../internals/to-object');
 var toAbsoluteIndex = require('../internals/to-absolute-index');
-var toLength = require('../internals/to-length');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 
 var min = Math.min;
 
@@ -10,7 +10,7 @@ var min = Math.min;
 // eslint-disable-next-line es/no-array-prototype-copywithin -- safe
 module.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) {
   var O = toObject(this);
-  var len = toLength(O.length);
+  var len = lengthOfArrayLike(O);
   var to = toAbsoluteIndex(target, len);
   var from = toAbsoluteIndex(start, len);
   var end = arguments.length > 2 ? arguments[2] : undefined;

package/internals/array-fill.js

@@ -1,13 +1,13 @@
 'use strict';
 var toObject = require('../internals/to-object');
 var toAbsoluteIndex = require('../internals/to-absolute-index');
-var toLength = require('../internals/to-length');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 
 // `Array.prototype.fill` method implementation
 // https://tc39.es/ecma262/#sec-array.prototype.fill
 module.exports = function fill(value /* , start = 0, end = @length */) {
   var O = toObject(this);
-  var length = toLength(O.length);
+  var length = lengthOfArrayLike(O);
   var argumentsLength = arguments.length;
   var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length);
   var end = argumentsLength > 2 ? arguments[2] : undefined;

package/internals/array-from-async.js

@@ -0,0 +1,36 @@
+'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 getBuiltIn = require('../internals/get-built-in');
+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 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, 2);
+    var usingAsyncIterator = getMethod(O, ASYNC_ITERATOR);
+    var usingSyncIterator = usingAsyncIterator ? undefined : getIteratorMethod(O) || arrayIterator;
+    var A = isConstructor(C) ? new C() : [];
+    var iterator = usingAsyncIterator
+      ? getAsyncIterator(O, usingAsyncIterator)
+      : new AsyncFromSyncIterator(getIterator(O, usingSyncIterator));
+    resolve(toArray(iterator, mapfn, A));
+  });
+};

package/internals/array-from.js

@@ -3,7 +3,8 @@ 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 toLength = require('../internals/to-length');
+var isConstructor = require('../internals/is-constructor');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 var createProperty = require('../internals/create-property');
 var getIterator = require('../internals/get-iterator');
 var getIteratorMethod = require('../internals/get-iterator-method');
@@ -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);
+    length = lengthOfArrayLike(O);
+    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-group-by.js

@@ -1,8 +1,8 @@
 var bind = require('../internals/function-bind-context');
 var IndexedObject = require('../internals/indexed-object');
 var toObject = require('../internals/to-object');
-var toLength = require('../internals/to-length');
 var toPropertyKey = require('../internals/to-property-key');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 var objectCreate = require('../internals/object-create');
 var arrayFromConstructorAndList = require('../internals/array-from-constructor-and-list');
 
@@ -13,7 +13,7 @@ module.exports = function ($this, callbackfn, that, specificConstructor) {
   var self = IndexedObject(O);
   var boundFunction = bind(callbackfn, that, 3);
   var target = objectCreate(null);
-  var length = toLength(self.length);
+  var length = lengthOfArrayLike(self);
   var index = 0;
   var Constructor, key, value;
   for (;length > index; index++) {

package/internals/array-includes.js

@@ -1,12 +1,12 @@
 var toIndexedObject = require('../internals/to-indexed-object');
-var toLength = require('../internals/to-length');
 var toAbsoluteIndex = require('../internals/to-absolute-index');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 
 // `Array.prototype.{ indexOf, includes }` methods implementation
 var createMethod = function (IS_INCLUDES) {
   return function ($this, el, fromIndex) {
     var O = toIndexedObject($this);
-    var length = toLength(O.length);
+    var length = lengthOfArrayLike(O);
     var index = toAbsoluteIndex(fromIndex, length);
     var value;
     // Array#includes uses SameValueZero equality algorithm

package/internals/array-iteration-from-last.js

@@ -1,7 +1,7 @@
 var bind = require('../internals/function-bind-context');
 var IndexedObject = require('../internals/indexed-object');
 var toObject = require('../internals/to-object');
-var toLength = require('../internals/to-length');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 
 // `Array.prototype.{ findLast, findLastIndex }` methods implementation
 var createMethod = function (TYPE) {
@@ -10,7 +10,7 @@ var createMethod = function (TYPE) {
     var O = toObject($this);
     var self = IndexedObject(O);
     var boundFunction = bind(callbackfn, that, 3);
-    var index = toLength(self.length);
+    var index = lengthOfArrayLike(self);
     var value, result;
     while (index-- > 0) {
       value = self[index];

package/internals/array-iteration.js

@@ -1,7 +1,7 @@
 var bind = require('../internals/function-bind-context');
 var IndexedObject = require('../internals/indexed-object');
 var toObject = require('../internals/to-object');
-var toLength = require('../internals/to-length');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 var arraySpeciesCreate = require('../internals/array-species-create');
 
 var push = [].push;
@@ -19,7 +19,7 @@ var createMethod = function (TYPE) {
     var O = toObject($this);
     var self = IndexedObject(O);
     var boundFunction = bind(callbackfn, that, 3);
-    var length = toLength(self.length);
+    var length = lengthOfArrayLike(self);
     var index = 0;
     var create = specificCreate || arraySpeciesCreate;
     var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;

package/internals/array-last-index-of.js

@@ -1,8 +1,8 @@
 'use strict';
 /* eslint-disable es/no-array-prototype-lastindexof -- safe */
 var toIndexedObject = require('../internals/to-indexed-object');
-var toInteger = require('../internals/to-integer');
-var toLength = require('../internals/to-length');
+var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 var arrayMethodIsStrict = require('../internals/array-method-is-strict');
 
 var min = Math.min;
@@ -17,9 +17,9 @@ module.exports = FORCED ? function lastIndexOf(searchElement /* , fromIndex = @[
   // convert -0 to +0
   if (NEGATIVE_ZERO) return $lastIndexOf.apply(this, arguments) || 0;
   var O = toIndexedObject(this);
-  var length = toLength(O.length);
+  var length = lengthOfArrayLike(O);
   var index = length - 1;
-  if (arguments.length > 1) index = min(index, toInteger(arguments[1]));
+  if (arguments.length > 1) index = min(index, toIntegerOrInfinity(arguments[1]));
   if (index < 0) index = length + index;
   for (;index >= 0; index--) if (index in O && O[index] === searchElement) return index || 0;
   return -1;

package/internals/array-reduce.js

@@ -1,15 +1,15 @@
-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');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 
 // `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);
+    var length = lengthOfArrayLike(O);
     var index = IS_RIGHT ? length - 1 : 0;
     var i = IS_RIGHT ? -1 : 1;
     if (argumentsLength < 2) while (true) {

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,5 +1,6 @@
 'use strict';
-var toLength = require('../internals/to-length');
+var aCallable = require('../internals/a-callable');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
 var toObject = require('../internals/to-object');
 var getBuiltIn = require('../internals/get-built-in');
 var arraySpeciesCreate = require('../internals/array-species-create');
@@ -10,16 +11,15 @@ var push = [].push;
 // https://github.com/tc39/proposal-array-unique
 module.exports = function uniqueBy(resolver) {
   var that = toObject(this);
-  var length = toLength(that.length);
+  var length = lengthOfArrayLike(that);
   var result = arraySpeciesCreate(that, 0);
   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);