core-js 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-buffer-view-core.js

@@ -2,9 +2,11 @@
 var NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-native');
 var DESCRIPTORS = require('../internals/descriptors');
 var global = require('../internals/global');
+var isCallable = require('../internals/is-callable');
 var isObject = require('../internals/is-object');
-var has = require('../internals/has');
+var hasOwn = require('../internals/has-own-property');
 var classof = require('../internals/classof');
+var tryToString = require('../internals/try-to-string');
 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
 var redefine = require('../internals/redefine');
 var defineProperty = require('../internals/object-define-property').f;
@@ -51,15 +53,15 @@ var isView = function isView(it) {
   if (!isObject(it)) return false;
   var klass = classof(it);
   return klass === 'DataView'
-    || has(TypedArrayConstructorsList, klass)
-    || has(BigIntArrayConstructorsList, klass);
+    || hasOwn(TypedArrayConstructorsList, klass)
+    || hasOwn(BigIntArrayConstructorsList, klass);
 };
 
 var isTypedArray = function (it) {
   if (!isObject(it)) return false;
   var klass = classof(it);
-  return has(TypedArrayConstructorsList, klass)
-    || has(BigIntArrayConstructorsList, klass);
+  return hasOwn(TypedArrayConstructorsList, klass)
+    || hasOwn(BigIntArrayConstructorsList, klass);
 };
 
 var aTypedArray = function (it) {
@@ -68,16 +70,15 @@ var aTypedArray = function (it) {
 };
 
 var aTypedArrayConstructor = function (C) {
-  if (setPrototypeOf && !isPrototypeOf.call(TypedArray, C)) {
-    throw TypeError('Target is not a typed array constructor');
-  } return C;
+  if (isCallable(C) && (!setPrototypeOf || isPrototypeOf.call(TypedArray, C))) return C;
+  throw TypeError(tryToString(C) + ' is not a typed array constructor');
 };
 
 var exportTypedArrayMethod = function (KEY, property, forced) {
   if (!DESCRIPTORS) return;
   if (forced) for (var ARRAY in TypedArrayConstructorsList) {
     var TypedArrayConstructor = global[ARRAY];
-    if (TypedArrayConstructor && has(TypedArrayConstructor.prototype, KEY)) try {
+    if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
       delete TypedArrayConstructor.prototype[KEY];
     } catch (error) { /* empty */ }
   }
@@ -93,7 +94,7 @@ var exportTypedArrayStaticMethod = function (KEY, property, forced) {
   if (setPrototypeOf) {
     if (forced) for (ARRAY in TypedArrayConstructorsList) {
       TypedArrayConstructor = global[ARRAY];
-      if (TypedArrayConstructor && has(TypedArrayConstructor, KEY)) try {
+      if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
         delete TypedArrayConstructor[KEY];
       } catch (error) { /* empty */ }
     }
@@ -126,7 +127,7 @@ for (NAME in BigIntArrayConstructorsList) {
 }
 
 // WebKit bug - typed arrays constructors prototype is Object.prototype
-if (!NATIVE_ARRAY_BUFFER_VIEWS || typeof TypedArray != 'function' || TypedArray === Function.prototype) {
+if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
   // eslint-disable-next-line no-shadow -- safe
   TypedArray = function TypedArray() {
     throw TypeError('Incorrect invocation');
@@ -148,7 +149,7 @@ if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !==
   setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
 }
 
-if (DESCRIPTORS && !has(TypedArrayPrototype, TO_STRING_TAG)) {
+if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
   TYPED_ARRAY_TAG_REQIRED = true;
   defineProperty(TypedArrayPrototype, TO_STRING_TAG, { get: function () {
     return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;

package/internals/array-buffer.js

@@ -2,11 +2,12 @@
 var global = require('../internals/global');
 var DESCRIPTORS = require('../internals/descriptors');
 var NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-native');
+var FunctionName = require('../internals/function-name');
 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
 var redefineAll = require('../internals/redefine-all');
 var fails = require('../internals/fails');
 var anInstance = require('../internals/an-instance');
-var toInteger = require('../internals/to-integer');
+var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');
 var toLength = require('../internals/to-length');
 var toIndex = require('../internals/to-index');
 var IEEE754 = require('../internals/ieee754');
@@ -18,6 +19,8 @@ var arrayFill = require('../internals/array-fill');
 var setToStringTag = require('../internals/set-to-string-tag');
 var InternalStateModule = require('../internals/internal-state');
 
+var PROPER_FUNCTION_NAME = FunctionName.PROPER;
+var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
 var getInternalState = InternalStateModule.get;
 var setInternalState = InternalStateModule.set;
 var ARRAY_BUFFER = 'ArrayBuffer';
@@ -98,7 +101,7 @@ if (!NATIVE_ARRAY_BUFFER) {
     anInstance(this, $DataView, DATA_VIEW);
     anInstance(buffer, $ArrayBuffer, DATA_VIEW);
     var bufferLength = getInternalState(buffer).byteLength;
-    var offset = toInteger(byteOffset);
+    var offset = toIntegerOrInfinity(byteOffset);
     if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset');
     byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength);
     if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH);
@@ -174,6 +177,7 @@ if (!NATIVE_ARRAY_BUFFER) {
     }
   });
 } else {
+  var INCORRECT_ARRAY_BUFFER_NAME = PROPER_FUNCTION_NAME && NativeArrayBuffer.name !== ARRAY_BUFFER;
   /* eslint-disable no-new -- required for testing */
   if (!fails(function () {
     NativeArrayBuffer(1);
@@ -183,7 +187,7 @@ if (!NATIVE_ARRAY_BUFFER) {
     new NativeArrayBuffer();
     new NativeArrayBuffer(1.5);
     new NativeArrayBuffer(NaN);
-    return NativeArrayBuffer.name != ARRAY_BUFFER;
+    return INCORRECT_ARRAY_BUFFER_NAME && !CONFIGURABLE_FUNCTION_NAME;
   })) {
   /* eslint-enable no-new -- required for testing */
     $ArrayBuffer = function ArrayBuffer(length) {
@@ -197,6 +201,8 @@ if (!NATIVE_ARRAY_BUFFER) {
       }
     }
     ArrayBufferPrototype.constructor = $ArrayBuffer;
+  } else if (INCORRECT_ARRAY_BUFFER_NAME && CONFIGURABLE_FUNCTION_NAME) {
+    createNonEnumerableProperty(NativeArrayBuffer, 'name', ARRAY_BUFFER);
   }
 
   // WebKit bug - the same parent prototype for typed arrays and data view

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];