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

@@ -10,6 +10,7 @@ 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;
+var isPrototypeOf = require('../internals/object-is-prototype-of');
 var getPrototypeOf = require('../internals/object-get-prototype-of');
 var setPrototypeOf = require('../internals/object-set-prototype-of');
 var wellKnownSymbol = require('../internals/well-known-symbol');
@@ -22,7 +23,7 @@ var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototyp
 var TypedArray = Int8Array && getPrototypeOf(Int8Array);
 var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
 var ObjectPrototype = Object.prototype;
-var isPrototypeOf = ObjectPrototype.isPrototypeOf;
+var TypeError = global.TypeError;
 
 var TO_STRING_TAG = wellKnownSymbol('toStringTag');
 var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
@@ -70,7 +71,7 @@ var aTypedArray = function (it) {
 };
 
 var aTypedArrayConstructor = function (C) {
-  if (isCallable(C) && (!setPrototypeOf || isPrototypeOf.call(TypedArray, C))) return C;
+  if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
   throw TypeError(tryToString(C) + ' is not a typed array constructor');
 };