core-js 3.17.0 → 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-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 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;
@@ -68,9 +70,8 @@ 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) {
@@ -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');

package/internals/array-buffer.js

@@ -2,6 +2,7 @@
 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');
@@ -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';
@@ -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-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

@@ -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;
@@ -40,8 +41,8 @@ module.exports = function (nextHandler, IS_ITERATOR) {
       return new Promise(function (resolve, reject) {
         var state = getInternalState(that);
         var iterator = state.iterator;
-        iterator.done = true;
-        var $$return = iterator['return'];
+        state.done = true;
+        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);
@@ -54,8 +55,8 @@ module.exports = function (nextHandler, IS_ITERATOR) {
       return new Promise(function (resolve, reject) {
         var state = getInternalState(that);
         var iterator = state.iterator;
-        iterator.done = true;
-        var $$throw = iterator['throw'];
+        state.done = true;
+        var $$throw = getMethod(iterator, 'throw');
         if ($$throw === undefined) return reject(value);
         resolve($$throw.call(iterator, value));
       });