core-js-pure 3.18.2 → 3.19.2

package/es/promise/any.js

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

package/es/regexp/flags.js

@@ -1,6 +1,5 @@
 require('../../modules/es.regexp.flags');
-var flags = require('../../internals/regexp-flags');
+var uncurryThis = require('../../internals/function-uncurry-this');
+var regExpFlags = require('../../internals/regexp-flags');
 
-module.exports = function (it) {
-  return flags.call(it);
-};
+module.exports = uncurryThis(regExpFlags);

package/es/regexp/match.js

@@ -1,9 +1,10 @@
 require('../../modules/es.regexp.exec');
 require('../../modules/es.string.match');
+var call = require('../../internals/function-call');
 var wellKnownSymbol = require('../../internals/well-known-symbol');
 
 var MATCH = wellKnownSymbol('match');
 
 module.exports = function (it, str) {
-  return RegExp.prototype[MATCH].call(it, str);
+  return call(RegExp.prototype[MATCH], it, str);
 };

package/es/regexp/replace.js

@@ -1,9 +1,10 @@
 require('../../modules/es.regexp.exec');
 require('../../modules/es.string.replace');
+var call = require('../../internals/function-call');
 var wellKnownSymbol = require('../../internals/well-known-symbol');
 
 var REPLACE = wellKnownSymbol('replace');
 
 module.exports = function (it, str, replacer) {
-  return RegExp.prototype[REPLACE].call(it, str, replacer);
+  return call(RegExp.prototype[REPLACE], it, str, replacer);
 };

package/es/regexp/search.js

@@ -1,9 +1,10 @@
 require('../../modules/es.regexp.exec');
 require('../../modules/es.string.search');
+var call = require('../../internals/function-call');
 var wellKnownSymbol = require('../../internals/well-known-symbol');
 
 var SEARCH = wellKnownSymbol('search');
 
 module.exports = function (it, str) {
-  return RegExp.prototype[SEARCH].call(it, str);
+  return call(RegExp.prototype[SEARCH], it, str);
 };

package/es/regexp/split.js

@@ -1,9 +1,10 @@
 require('../../modules/es.regexp.exec');
 require('../../modules/es.string.split');
+var call = require('../../internals/function-call');
 var wellKnownSymbol = require('../../internals/well-known-symbol');
 
 var SPLIT = wellKnownSymbol('split');
 
 module.exports = function (it, str, limit) {
-  return RegExp.prototype[SPLIT].call(it, str, limit);
+  return call(RegExp.prototype[SPLIT], it, str, limit);
 };

package/es/regexp/test.js

@@ -1,6 +1,5 @@
 require('../../modules/es.regexp.exec');
 require('../../modules/es.regexp.test');
+var uncurryThis = require('../../internals/function-uncurry-this');
 
-module.exports = function (re, string) {
-  return RegExp.prototype.test.call(re, string);
-};
+module.exports = uncurryThis(/./.test);

package/es/regexp/to-string.js

@@ -1,5 +1,4 @@
 require('../../modules/es.regexp.to-string');
+var uncurryThis = require('../../internals/function-uncurry-this');
 
-module.exports = function toString(it) {
-  return RegExp.prototype.toString.call(it);
-};
+module.exports = uncurryThis(/./.toString);

package/es/string/iterator.js

@@ -1,9 +1,6 @@
 require('../../modules/es.object.to-string');
 require('../../modules/es.string.iterator');
+var uncurryThis = require('../../internals/function-uncurry-this');
 var Iterators = require('../../internals/iterators');
 
-var getStringIterator = Iterators.String;
-
-module.exports = function (it) {
-  return getStringIterator.call(it);
-};
+module.exports = uncurryThis(Iterators.String);

package/features/instance/at.js

@@ -1,13 +1,14 @@
-var arrayAt = require('../array/virtual/at');
-var stringAt = require('../string/virtual/at');
+var isPrototypeOf = require('../../internals/object-is-prototype-of');
+var arrayMethod = require('../array/virtual/at');
+var stringMethod = require('../string/virtual/at');
 
 var ArrayPrototype = Array.prototype;
 var StringPrototype = String.prototype;
 
 module.exports = function (it) {
   var own = it.at;
-  if (it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.at)) return arrayAt;
-  if (typeof it === 'string' || it === StringPrototype || (it instanceof String && own === StringPrototype.at)) {
-    return stringAt;
+  if (it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.at)) return arrayMethod;
+  if (typeof it == 'string' || it === StringPrototype || (isPrototypeOf(StringPrototype, it) && own === StringPrototype.at)) {
+    return stringMethod;
   } return own;
 };

package/features/instance/code-points.js

@@ -1,9 +1,10 @@
-var codePoints = require('../string/virtual/code-points');
+var isPrototypeOf = require('../../internals/object-is-prototype-of');
+var method = require('../string/virtual/code-points');
 
 var StringPrototype = String.prototype;
 
 module.exports = function (it) {
   var own = it.codePoints;
-  return typeof it === 'string' || it === StringPrototype
-    || (it instanceof String && own === StringPrototype.codePoints) ? codePoints : own;
+  return typeof it == 'string' || it === StringPrototype
+    || (isPrototypeOf(StringPrototype, it) && own === StringPrototype.codePoints) ? method : own;
 };

package/features/instance/filter-out.js

@@ -1,9 +1,10 @@
 // TODO: Remove from `core-js@4`
-var filterOut = require('../array/virtual/filter-out');
+var isPrototypeOf = require('../../internals/object-is-prototype-of');
+var method = require('../array/virtual/filter-out');
 
 var ArrayPrototype = Array.prototype;
 
 module.exports = function (it) {
   var own = it.filterOut;
-  return it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.filterOut) ? filterOut : own;
+  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.filterOut) ? method : own;
 };

package/features/instance/filter-reject.js

@@ -1,8 +1,9 @@
-var filterReject = require('../array/virtual/filter-reject');
+var isPrototypeOf = require('../../internals/object-is-prototype-of');
+var method = require('../array/virtual/filter-reject');
 
 var ArrayPrototype = Array.prototype;
 
 module.exports = function (it) {
   var own = it.filterReject;
-  return it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.filterReject) ? filterReject : own;
+  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.filterReject) ? method : own;
 };

package/features/instance/find-last-index.js

@@ -1,8 +1,9 @@
-var findLastIndex = require('../array/virtual/find-last-index');
+var isPrototypeOf = require('../../internals/object-is-prototype-of');
+var method = require('../array/virtual/find-last-index');
 
 var ArrayPrototype = Array.prototype;
 
 module.exports = function (it) {
   var own = it.findLastIndex;
-  return it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.findLastIndex) ? findLastIndex : own;
+  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.findLastIndex) ? method : own;
 };

package/features/instance/find-last.js

@@ -1,8 +1,9 @@
-var findLast = require('../array/virtual/find-last');
+var isPrototypeOf = require('../../internals/object-is-prototype-of');
+var method = require('../array/virtual/find-last');
 
 var ArrayPrototype = Array.prototype;
 
 module.exports = function (it) {
   var own = it.findLast;
-  return it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.findLast) ? findLast : own;
+  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.findLast) ? method : own;
 };

package/features/instance/group-by.js

@@ -1,8 +1,9 @@
-var groupBy = require('../array/virtual/group-by');
+var isPrototypeOf = require('../../internals/object-is-prototype-of');
+var method = require('../array/virtual/group-by');
 
 var ArrayPrototype = Array.prototype;
 
 module.exports = function (it) {
   var own = it.groupBy;
-  return it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.groupBy) ? groupBy : own;
+  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.groupBy) ? method : own;
 };

package/features/instance/unique-by.js

@@ -1,8 +1,9 @@
-var uniqueBy = require('../array/virtual/unique-by');
+var isPrototypeOf = require('../../internals/object-is-prototype-of');
+var method = require('../array/virtual/unique-by');
 
 var ArrayPrototype = Array.prototype;
 
 module.exports = function (it) {
   var own = it.uniqueBy;
-  return it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.uniqueBy) ? uniqueBy : own;
+  return it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.uniqueBy) ? method : own;
 };

package/features/map/from.js

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

package/features/map/group-by.js

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

package/features/map/key-by.js

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

package/features/map/of.js

@@ -2,12 +2,13 @@
 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 apply = require('../../internals/function-apply');
+var isCallable = require('../../internals/is-callable');
 
 var Map = path.Map;
 var mapOf = Map.of;
 
 module.exports = function of() {
-  return mapOf.apply(isCallable(this) ? this : Map, arguments);
+  return apply(mapOf, isCallable(this) ? this : Map, arguments);
 };

package/features/promise/try.js

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

package/features/set/from.js

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

package/features/set/of.js

@@ -2,12 +2,13 @@
 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 apply = require('../../internals/function-apply');
+var isCallable = require('../../internals/is-callable');
 
 var Set = path.Set;
 var setOf = Set.of;
 
 module.exports = function of() {
-  return setOf.apply(isCallable(this) ? this : Set, arguments);
+  return apply(setOf, isCallable(this) ? this : Set, arguments);
 };

package/features/weak-map/from.js

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

package/features/weak-map/of.js

@@ -2,12 +2,13 @@
 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 apply = require('../../internals/function-apply');
+var isCallable = require('../../internals/is-callable');
 
 var WeakMap = path.WeakMap;
 var weakMapOf = WeakMap.of;
 
 module.exports = function of() {
-  return weakMapOf.apply(isCallable(this) ? this : WeakMap, arguments);
+  return apply(weakMapOf, isCallable(this) ? this : WeakMap, arguments);
 };

package/features/weak-set/from.js

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

package/features/weak-set/of.js

@@ -2,12 +2,13 @@
 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 apply = require('../../internals/function-apply');
+var isCallable = require('../../internals/is-callable');
 
 var WeakSet = path.WeakSet;
 var weakSetOf = WeakSet.of;
 
 module.exports = function of() {
-  return weakSetOf.apply(isCallable(this) ? this : WeakSet, arguments);
+  return apply(weakSetOf, isCallable(this) ? this : WeakSet, arguments);
 };

package/internals/a-callable.js

@@ -1,6 +1,9 @@
+var global = require('../internals/global');
 var isCallable = require('../internals/is-callable');
 var tryToString = require('../internals/try-to-string');
 
+var TypeError = global.TypeError;
+
 // `Assert: IsCallable(argument) is true`
 module.exports = function (argument) {
   if (isCallable(argument)) return argument;

package/internals/a-constructor.js

@@ -1,6 +1,9 @@
+var global = require('../internals/global');
 var isConstructor = require('../internals/is-constructor');
 var tryToString = require('../internals/try-to-string');
 
+var TypeError = global.TypeError;
+
 // `Assert: IsConstructor(argument) is true`
 module.exports = function (argument) {
   if (isConstructor(argument)) return argument;

package/internals/a-possible-prototype.js

@@ -1,6 +1,10 @@
+var global = require('../internals/global');
 var isCallable = require('../internals/is-callable');
 
+var String = global.String;
+var TypeError = global.TypeError;
+
 module.exports = function (argument) {
-  if (typeof argument === 'object' || isCallable(argument)) return 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,4 +1,9 @@
-module.exports = function (it, Constructor, name) {
-  if (it instanceof Constructor) return it;
-  throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
+var global = require('../internals/global');
+var isPrototypeOf = require('../internals/object-is-prototype-of');
+
+var TypeError = global.TypeError;
+
+module.exports = function (it, Prototype) {
+  if (isPrototypeOf(Prototype, it)) return it;
+  throw TypeError('Incorrect invocation');
 };

package/internals/an-object.js

@@ -1,5 +1,9 @@
+var global = require('../internals/global');
 var isObject = require('../internals/is-object');
 
+var String = global.String;
+var TypeError = global.TypeError;
+
 // `Assert: Type(argument) is Object`
 module.exports = function (argument) {
   if (isObject(argument)) return argument;

package/internals/array-buffer-native.js

@@ -1,2 +1,2 @@
 // eslint-disable-next-line es/no-typed-arrays -- safe
-module.exports = typeof ArrayBuffer !== 'undefined' && typeof DataView !== 'undefined';
+module.exports = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';

package/internals/array-buffer-non-extensible.js

@@ -0,0 +1,10 @@
+// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it
+var fails = require('../internals/fails');
+
+module.exports = fails(function () {
+  if (typeof ArrayBuffer == 'function') {
+    var buffer = new ArrayBuffer(8);
+    // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe
+    if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });
+  }
+});

package/internals/array-from-async.js

@@ -24,7 +24,7 @@ module.exports = function fromAsync(asyncItems /* , mapfn = undefined, thisArg =
   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);
+    if (mapfn !== undefined) mapfn = bind(mapfn, thisArg);
     var usingAsyncIterator = getMethod(O, ASYNC_ITERATOR);
     var usingSyncIterator = usingAsyncIterator ? undefined : getIteratorMethod(O) || arrayIterator;
     var A = isConstructor(C) ? new C() : [];

package/internals/array-from.js

@@ -1,5 +1,7 @@
 'use strict';
+var global = require('../internals/global');
 var bind = require('../internals/function-bind-context');
+var call = require('../internals/function-call');
 var toObject = require('../internals/to-object');
 var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');
 var isArrayIteratorMethod = require('../internals/is-array-iterator-method');
@@ -9,6 +11,8 @@ var createProperty = require('../internals/create-property');
 var getIterator = require('../internals/get-iterator');
 var getIteratorMethod = require('../internals/get-iterator-method');
 
+var Array = global.Array;
+
 // `Array.from` method implementation
 // https://tc39.es/ecma262/#sec-array.from
 module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
@@ -17,7 +21,7 @@ module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undef
   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);
+  if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);
   var iteratorMethod = getIteratorMethod(O);
   var index = 0;
   var length, result, step, iterator, next, value;
@@ -26,7 +30,7 @@ module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undef
     iterator = getIterator(O, iteratorMethod);
     next = iterator.next;
     result = IS_CONSTRUCTOR ? new this() : [];
-    for (;!(step = next.call(iterator)).done; index++) {
+    for (;!(step = call(next, iterator)).done; index++) {
       value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
       createProperty(result, index, value);
     }

package/internals/array-group-by.js

@@ -1,4 +1,6 @@
+var global = require('../internals/global');
 var bind = require('../internals/function-bind-context');
+var uncurryThis = require('../internals/function-uncurry-this');
 var IndexedObject = require('../internals/indexed-object');
 var toObject = require('../internals/to-object');
 var toPropertyKey = require('../internals/to-property-key');
@@ -6,12 +8,13 @@ var lengthOfArrayLike = require('../internals/length-of-array-like');
 var objectCreate = require('../internals/object-create');
 var arrayFromConstructorAndList = require('../internals/array-from-constructor-and-list');
 
-var push = [].push;
+var Array = global.Array;
+var push = uncurryThis([].push);
 
 module.exports = function ($this, callbackfn, that, specificConstructor) {
   var O = toObject($this);
   var self = IndexedObject(O);
-  var boundFunction = bind(callbackfn, that, 3);
+  var boundFunction = bind(callbackfn, that);
   var target = objectCreate(null);
   var length = lengthOfArrayLike(self);
   var index = 0;
@@ -21,7 +24,7 @@ module.exports = function ($this, callbackfn, that, specificConstructor) {
     key = toPropertyKey(boundFunction(value, index, O));
     // in some IE10 builds, `hasOwnProperty` returns incorrect result on integer keys
     // but since it's a `null` prototype object, we can safely use `in`
-    if (key in target) push.call(target[key], value);
+    if (key in target) push(target[key], value);
     else target[key] = [value];
   }
   if (specificConstructor) {

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

@@ -9,7 +9,7 @@ var createMethod = function (TYPE) {
   return function ($this, callbackfn, that) {
     var O = toObject($this);
     var self = IndexedObject(O);
-    var boundFunction = bind(callbackfn, that, 3);
+    var boundFunction = bind(callbackfn, that);
     var index = lengthOfArrayLike(self);
     var value, result;
     while (index-- > 0) {

package/internals/array-iteration.js

@@ -1,10 +1,11 @@
 var bind = require('../internals/function-bind-context');
+var uncurryThis = require('../internals/function-uncurry-this');
 var IndexedObject = require('../internals/indexed-object');
 var toObject = require('../internals/to-object');
 var lengthOfArrayLike = require('../internals/length-of-array-like');
 var arraySpeciesCreate = require('../internals/array-species-create');
 
-var push = [].push;
+var push = uncurryThis([].push);
 
 // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
 var createMethod = function (TYPE) {
@@ -18,7 +19,7 @@ var createMethod = function (TYPE) {
   return function ($this, callbackfn, that, specificCreate) {
     var O = toObject($this);
     var self = IndexedObject(O);
-    var boundFunction = bind(callbackfn, that, 3);
+    var boundFunction = bind(callbackfn, that);
     var length = lengthOfArrayLike(self);
     var index = 0;
     var create = specificCreate || arraySpeciesCreate;
@@ -33,10 +34,10 @@ var createMethod = function (TYPE) {
           case 3: return true;              // some
           case 5: return value;             // find
           case 6: return index;             // findIndex
-          case 2: push.call(target, value); // filter
+          case 2: push(target, value);      // filter
         } else switch (TYPE) {
           case 4: return false;             // every
-          case 7: push.call(target, value); // filterReject
+          case 7: push(target, value);      // filterReject
         }
       }
     }

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

@@ -1,5 +1,6 @@
 'use strict';
 /* eslint-disable es/no-array-prototype-lastindexof -- safe */
+var apply = require('../internals/function-apply');
 var toIndexedObject = require('../internals/to-indexed-object');
 var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');
 var lengthOfArrayLike = require('../internals/length-of-array-like');
@@ -15,7 +16,7 @@ var FORCED = NEGATIVE_ZERO || !STRICT_METHOD;
 // https://tc39.es/ecma262/#sec-array.prototype.lastindexof
 module.exports = FORCED ? function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) {
   // convert -0 to +0
-  if (NEGATIVE_ZERO) return $lastIndexOf.apply(this, arguments) || 0;
+  if (NEGATIVE_ZERO) return apply($lastIndexOf, this, arguments) || 0;
   var O = toIndexedObject(this);
   var length = lengthOfArrayLike(O);
   var index = length - 1;