core-js 3.49.0 → 3.50.0

package/internals/get-iterator-method.js

@@ -1,14 +1,11 @@
 'use strict';
-var classof = require('../internals/classof');
-var getMethod = require('../internals/get-method');
-var isNullOrUndefined = require('../internals/is-null-or-undefined');
-var Iterators = require('../internals/iterators');
+var classof = require('../internals/classof-raw');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 
 var ITERATOR = wellKnownSymbol('iterator');
+var ArrayPrototype = Array.prototype;
 
 module.exports = function (it) {
-  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
-    || getMethod(it, '@@iterator')
-    || Iterators[classof(it)];
+  return it[ITERATOR] || it['@@iterator']
+    || (classof(it) === 'Arguments' ? ArrayPrototype[ITERATOR] : undefined);
 };

package/internals/get-iterator-record.js

@@ -1,5 +1,5 @@
 'use strict';
-var getIterator = require('../internals/get-iterator');
+var getIterator = require('../internals/get-iterator-internal');
 var getIteratorDirect = require('../internals/get-iterator-direct');
 
 module.exports = function (argument) {

package/internals/get-iterator.js

@@ -1,14 +1,13 @@
 'use strict';
 var call = require('../internals/function-call');
-var aCallable = require('../internals/a-callable');
-var anObject = require('../internals/an-object');
+var isCallable = require('../internals/is-callable');
 var tryToString = require('../internals/try-to-string');
 var getIteratorMethod = require('../internals/get-iterator-method');
 
 var $TypeError = TypeError;
 
-module.exports = function (argument, usingIterator) {
-  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
-  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
+module.exports = function (argument) {
+  var iteratorMethod = getIteratorMethod(argument);
+  if (isCallable(iteratorMethod)) return call(iteratorMethod, argument);
   throw new $TypeError(tryToString(argument) + ' is not iterable');
 };

package/internals/is-iterable.js

@@ -1,17 +1,11 @@
 'use strict';
-var classof = require('../internals/classof');
-var hasOwn = require('../internals/has-own-property');
-var isNullOrUndefined = require('../internals/is-null-or-undefined');
+var classof = require('../internals/classof-raw');
 var wellKnownSymbol = require('../internals/well-known-symbol');
-var Iterators = require('../internals/iterators');
 
 var ITERATOR = wellKnownSymbol('iterator');
-var $Object = Object;
 
 module.exports = function (it) {
-  if (isNullOrUndefined(it)) return false;
-  var O = $Object(it);
-  return O[ITERATOR] !== undefined
-    || '@@iterator' in O
-    || hasOwn(Iterators, classof(O));
+  return it[ITERATOR] !== undefined
+    || it['@@iterator'] !== undefined
+    || classof(it) === 'Arguments';
 };

package/internals/iterate.js

@@ -6,8 +6,8 @@ var tryToString = require('../internals/try-to-string');
 var isArrayIteratorMethod = require('../internals/is-array-iterator-method');
 var lengthOfArrayLike = require('../internals/length-of-array-like');
 var isPrototypeOf = require('../internals/object-is-prototype-of');
-var getIterator = require('../internals/get-iterator');
-var getIteratorMethod = require('../internals/get-iterator-method');
+var getIterator = require('../internals/get-iterator-internal');
+var getIteratorMethod = require('../internals/get-iterator-method-internal');
 var iteratorClose = require('../internals/iterator-close');
 
 var $TypeError = TypeError;

package/internals/iterator-chunk-size-validation.js

@@ -0,0 +1,17 @@
+'use strict';
+var isIntegralNumber = require('../internals/is-integral-number');
+var iteratorClose = require('../internals/iterator-close');
+
+var $RangeError = RangeError;
+var $TypeError = TypeError;
+
+var CHUNK_SIZE_VALIDATION_ERROR = 'Chunk size must be an integer in [1, 2^32-1]';
+
+module.exports = function (chunkSize, iterator) {
+  if (typeof chunkSize != 'number' || !isIntegralNumber(chunkSize)) {
+    return iteratorClose(iterator, 'throw', new $TypeError(CHUNK_SIZE_VALIDATION_ERROR));
+  }
+  if (chunkSize === 0 || chunkSize >>> 0 !== chunkSize) {
+    return iteratorClose(iterator, 'throw', new $RangeError(CHUNK_SIZE_VALIDATION_ERROR));
+  }
+};

package/internals/iterator-cleanup-state.js

@@ -0,0 +1,6 @@
+'use strict';
+// release references held by exhausted / closed iterator helpers to allow GC of the source chain
+module.exports = function (state) {
+  state.iterator = state.next = state.nextHandler = state.mapper = state.predicate = state.inner =
+    state.iterables = state.iters = state.openIters = state.padding = state.finishResults = state.buffer = null;
+};

package/internals/iterator-create-proxy.js

@@ -10,6 +10,7 @@ var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype
 var createIterResultObject = require('../internals/create-iter-result-object');
 var iteratorClose = require('../internals/iterator-close');
 var iteratorCloseAll = require('../internals/iterator-close-all');
+var cleanupState = require('../internals/iterator-cleanup-state');
 
 var TO_STRING_TAG = wellKnownSymbol('toStringTag');
 var ITERATOR_HELPER = 'IteratorHelper';
@@ -31,29 +32,34 @@ var createIteratorProxyPrototype = function (IS_ITERATOR) {
       if (state.done) return createIterResultObject(undefined, true);
       try {
         var result = state.nextHandler();
+        if (state.done) cleanupState(state);
         return state.returnHandlerResult ? result : createIterResultObject(result, state.done);
       } catch (error) {
         state.done = true;
+        cleanupState(state);
         throw error;
       }
     },
     'return': function () {
       var state = getInternalState(this);
       var iterator = state.iterator;
+      var inner = state.inner;
+      var openIters = state.openIters;
       var done = state.done;
       state.done = true;
       if (IS_ITERATOR) {
         var returnMethod = getMethod(iterator, 'return');
         return returnMethod ? call(returnMethod, iterator) : createIterResultObject(undefined, true);
       }
+      cleanupState(state);
       if (done) return createIterResultObject(undefined, true);
-      if (state.inner) try {
-        iteratorClose(state.inner.iterator, NORMAL);
+      if (inner) try {
+        iteratorClose(inner.iterator, NORMAL);
       } catch (error) {
         return iteratorClose(iterator, THROW, error);
       }
-      if (state.openIters) try {
-        iteratorCloseAll(state.openIters, NORMAL);
+      if (openIters) try {
+        iteratorCloseAll(openIters, NORMAL);
       } catch (error) {
         if (iterator) return iteratorClose(iterator, THROW, error);
         throw error;

package/internals/iterator-window.js

@@ -5,9 +5,9 @@ var createIteratorProxy = require('../internals/iterator-create-proxy');
 var createIterResultObject = require('../internals/create-iter-result-object');
 var getIteratorDirect = require('../internals/get-iterator-direct');
 var iteratorClose = require('../internals/iterator-close');
+var chunkSizeValidation = require('../internals/iterator-chunk-size-validation');
 var uncurryThis = require('../internals/function-uncurry-this');
 
-var $RangeError = RangeError;
 var $TypeError = TypeError;
 var push = uncurryThis([].push);
 var slice = uncurryThis([].slice);
@@ -36,9 +36,7 @@ var IteratorProxy = createIteratorProxy(function () {
 // https://github.com/tc39/proposal-iterator-chunking
 module.exports = function (O, windowSize, undersized) {
   anObject(O);
-  if (typeof windowSize != 'number' || !windowSize || windowSize >>> 0 !== windowSize) {
-    return iteratorClose(O, 'throw', new $RangeError('`windowSize` must be integer in [1, 2^32-1]'));
-  }
+  chunkSizeValidation(windowSize, O);
   if (undersized !== undefined && undersized !== 'only-full' && undersized !== ALLOW_PARTIAL) {
     return iteratorClose(O, 'throw', new $TypeError('Incorrect `undersized` argument'));
   }

package/internals/iterators.js

@@ -1,2 +1,2 @@
 'use strict';
-module.exports = {};
+module.exports = Object.create ? Object.create(null) : {};

package/internals/math-log1p.js

@@ -6,5 +6,7 @@ var log = Math.log;
 // eslint-disable-next-line es/no-math-log1p -- safe
 module.exports = Math.log1p || function log1p(x) {
   var n = +x;
-  return n > -1e-8 && n < 1e-8 ? n - n * n / 2 : log(1 + n);
+  if (n > -1e-8 && n < 1e-8) return n - n * n / 2;
+  var u = 1 + n;
+  return u === 1 ? n : n === u - 1 ? log(u) : n * log(u) / (u - 1);
 };

package/internals/shared-store.js

@@ -7,9 +7,9 @@ var SHARED = '__core-js_shared__';
 var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
 
 (store.versions || (store.versions = [])).push({
-  version: '3.49.0',
+  version: '3.50.0',
   mode: IS_PURE ? 'pure' : 'global',
   copyright: '© 2013–2025 Denis Pushkarev (zloirock.ru), 2025–2026 CoreJS Company (core-js.io). All rights reserved.',
-  license: 'https://github.com/zloirock/core-js/blob/v3.49.0/LICENSE',
+  license: 'https://github.com/zloirock/core-js/blob/v3.50.0/LICENSE',
   source: 'https://github.com/zloirock/core-js'
 });

package/internals/shared.js

@@ -1,6 +1,8 @@
 'use strict';
 var store = require('../internals/shared-store');
+// eslint-disable-next-line es/no-object-create -- safe
+var create = Object.create || Object;
 
 module.exports = function (key, value) {
-  return store[key] || (store[key] = value || {});
+  return store[key] || (store[key] = value || create(null));
 };

package/internals/typed-array-from.js

@@ -5,8 +5,8 @@ var aCallable = require('../internals/a-callable');
 var aConstructor = require('../internals/a-constructor');
 var toObject = require('../internals/to-object');
 var lengthOfArrayLike = require('../internals/length-of-array-like');
-var getIterator = require('../internals/get-iterator');
-var getIteratorMethod = require('../internals/get-iterator-method');
+var getIterator = require('../internals/get-iterator-internal');
+var getIteratorMethod = require('../internals/get-iterator-method-internal');
 var isArrayIteratorMethod = require('../internals/is-array-iterator-method');
 var isBigIntArray = require('../internals/is-big-int-array');
 var aTypedArrayConstructor = require('../internals/array-buffer-view-core').aTypedArrayConstructor;

package/internals/uint8-from-base64.js

@@ -13,7 +13,9 @@ var base64UrlAlphabet = base64Map.c2iUrl;
 
 var SyntaxError = globalThis.SyntaxError;
 var TypeError = globalThis.TypeError;
+var $Array = globalThis.Array;
 var at = uncurryThis(''.charAt);
+var floor = Math.floor;
 
 var skipAsciiWhitespace = function (string, index) {
   var length = string.length;
@@ -82,7 +84,7 @@ module.exports = function (string, options, into, maxLength) {
   if (into) notDetached(into.buffer);
 
   var stringLength = string.length;
-  var bytes = into || [];
+  var bytes = into || $Array(floor(stringLength * 3 / 4));
   var written = 0;
   var read = 0;
   var chunk = '';
@@ -152,6 +154,6 @@ module.exports = function (string, options, into, maxLength) {
       }
     }
   }
-
+  if (!into) bytes.length = written;
   return { bytes: bytes, read: read, written: written };
 };

package/internals/uint8-from-hex.js

@@ -12,7 +12,7 @@ module.exports = function (string, into) {
   if (stringLength % 2 !== 0) throw new SyntaxError('String should be an even number of characters');
   var maxLength = into ? min(into.length, stringLength / 2) : stringLength / 2;
   var bytes = into || new Uint8Array(maxLength);
-  var segments = stringMatch(string, /.{2}/g);
+  var segments = stringMatch(string, /[\S\s]{2}/g);
   var written = 0;
   for (; written < maxLength; written++) {
     var result = +('0x' + segments[written] + '0');

package/internals/url-percent-coding.js

@@ -0,0 +1,171 @@
+'use strict';
+// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
+require('../modules/es.string.from-code-point');
+var getBuiltIn = require('../internals/get-built-in');
+var uncurryThis = require('../internals/function-uncurry-this');
+
+var fromCharCode = String.fromCharCode;
+var fromCodePoint = getBuiltIn('String', 'fromCodePoint');
+var $encodeURIComponent = encodeURIComponent;
+var $parseInt = parseInt;
+var charAt = uncurryThis(''.charAt);
+var push = uncurryThis([].push);
+var replace = uncurryThis(''.replace);
+var stringSlice = uncurryThis(''.slice);
+var exec = uncurryThis(/./.exec);
+
+var FALLBACK_REPLACER = '\uFFFD';
+var VALID_HEX = /^[0-9a-f]+$/i;
+// a surrogate pair is matched first, so a one-unit match is always a lone surrogate
+var SURROGATE = /[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF]/g;
+
+var parseHexOctet = function (string, start) {
+  var substr = stringSlice(string, start, start + 2);
+  if (!exec(VALID_HEX, substr)) return NaN;
+
+  return $parseInt(substr, 16);
+};
+
+var getLeadingOnes = function (octet) {
+  var count = 0;
+  for (var mask = 0x80; mask > 0 && (octet & mask) !== 0; mask >>= 1) {
+    count++;
+  }
+  return count;
+};
+
+var utf8Decode = function (octets) {
+  var codePoint = null;
+  var length = octets.length;
+
+  switch (length) {
+    case 1:
+      codePoint = octets[0];
+      break;
+    case 2:
+      codePoint = (octets[0] & 0x1F) << 6 | (octets[1] & 0x3F);
+      break;
+    case 3:
+      codePoint = (octets[0] & 0x0F) << 12 | (octets[1] & 0x3F) << 6 | (octets[2] & 0x3F);
+      break;
+    case 4:
+      codePoint = (octets[0] & 0x07) << 18 | (octets[1] & 0x3F) << 12 | (octets[2] & 0x3F) << 6 | (octets[3] & 0x3F);
+      break;
+  }
+
+  // reject surrogates, overlong encodings, and out-of-range codepoints
+  if (codePoint === null
+    || codePoint > 0x10FFFF
+    || (codePoint >= 0xD800 && codePoint <= 0xDFFF)
+    || codePoint < (length > 3 ? 0x10000 : length > 2 ? 0x800 : length > 1 ? 0x80 : 0)
+  ) return null;
+
+  return codePoint;
+};
+
+var replaceLoneSurrogate = function (chunk) {
+  return chunk.length === 2 ? chunk : FALLBACK_REPLACER;
+};
+
+// https://url.spec.whatwg.org/#percent-decode
+/* eslint-disable max-depth -- ok */
+var decode = function (input) {
+  var length = input.length;
+  var result = '';
+  var i = 0;
+
+  while (i < length) {
+    var decodedChar = charAt(input, i);
+
+    if (decodedChar === '%') {
+      if (charAt(input, i + 1) === '%' || i + 3 > length) {
+        result += '%';
+        i++;
+        continue;
+      }
+
+      var octet = parseHexOctet(input, i + 1);
+
+      // eslint-disable-next-line no-self-compare -- NaN check
+      if (octet !== octet) {
+        result += decodedChar;
+        i++;
+        continue;
+      }
+
+      i += 2;
+      var byteSequenceLength = getLeadingOnes(octet);
+
+      if (byteSequenceLength === 0) {
+        decodedChar = fromCharCode(octet);
+      } else {
+        if (byteSequenceLength === 1 || byteSequenceLength > 4) {
+          result += FALLBACK_REPLACER;
+          i++;
+          continue;
+        }
+
+        var octets = [octet];
+        var sequenceIndex = 1;
+
+        while (sequenceIndex < byteSequenceLength) {
+          i++;
+          if (i + 3 > length || charAt(input, i) !== '%') break;
+
+          var nextByte = parseHexOctet(input, i + 1);
+
+          // eslint-disable-next-line no-self-compare -- NaN check
+          if (nextByte !== nextByte || nextByte > 191 || nextByte < 128) break;
+
+          // https://encoding.spec.whatwg.org/#utf-8-decoder - position-specific byte ranges
+          if (sequenceIndex === 1) {
+            if (octet === 0xE0 && nextByte < 0xA0) break;
+            if (octet === 0xED && nextByte > 0x9F) break;
+            if (octet === 0xF0 && nextByte < 0x90) break;
+            if (octet === 0xF4 && nextByte > 0x8F) break;
+          }
+
+          push(octets, nextByte);
+          i += 2;
+          sequenceIndex++;
+        }
+
+        if (octets.length !== byteSequenceLength) {
+          result += FALLBACK_REPLACER;
+          continue;
+        }
+
+        var codePoint = utf8Decode(octets);
+        if (codePoint === null) {
+          for (var replacement = 0; replacement < byteSequenceLength; replacement++) result += FALLBACK_REPLACER;
+          i++;
+          continue;
+        } else {
+          decodedChar = fromCodePoint(codePoint);
+        }
+      }
+    }
+
+    result += decodedChar;
+    i++;
+  }
+
+  return result;
+};
+/* eslint-enable max-depth -- ok */
+
+// https://url.spec.whatwg.org/#string-percent-encode-after-encoding
+// a lone surrogate is the only input `encodeURIComponent` throws on, and the UTF-8
+// encoder replaces it - so the throw selects the slow path instead of a per-call scan
+var encode = function (input) {
+  try {
+    return $encodeURIComponent(input);
+  } catch (error) {
+    return $encodeURIComponent(replace(input, SURROGATE, replaceLoneSurrogate));
+  }
+};
+
+module.exports = {
+  decode: decode,
+  encode: encode
+};

package/modules/es.date.to-json.js

@@ -11,7 +11,7 @@ var FORCED = fails(function () {
 
 // `Date.prototype.toJSON` method
 // https://tc39.es/ecma262/#sec-date.prototype.tojson
-$({ target: 'Date', proto: true, arity: 1, forced: FORCED }, {
+$({ target: 'Date', proto: true, forced: FORCED }, {
   // eslint-disable-next-line no-unused-vars -- required for `.length`
   toJSON: function toJSON(key) {
     var O = toObject(this);

package/modules/es.escape.js

@@ -8,6 +8,8 @@ var charCodeAt = uncurryThis(''.charCodeAt);
 var exec = uncurryThis(/./.exec);
 var numberToString = uncurryThis(1.1.toString);
 var toUpperCase = uncurryThis(''.toUpperCase);
+var join = uncurryThis([].join);
+var $Array = Array;
 
 var raw = /[\w*+\-./@]/;
 
@@ -22,22 +24,22 @@ var hex = function (code, length) {
 $({ global: true }, {
   escape: function escape(string) {
     var str = toString(string);
-    var result = '';
     var length = str.length;
-    var index = 0;
+    var result = $Array(length);
+    var index;
     var chr, code;
-    while (index < length) {
-      chr = charAt(str, index++);
+    for (index = 0; index < length; index++) {
+      chr = charAt(str, index);
       if (exec(raw, chr)) {
-        result += chr;
+        result[index] = chr;
       } else {
         code = charCodeAt(chr, 0);
         if (code < 256) {
-          result += '%' + toUpperCase(hex(code, 2));
+          result[index] = '%' + toUpperCase(hex(code, 2));
         } else {
-          result += '%u' + toUpperCase(hex(code, 4));
+          result[index] = '%u' + toUpperCase(hex(code, 4));
         }
       }
-    } return result;
+    } return join(result, '');
   }
 });

package/modules/es.iterator.concat.js

@@ -3,7 +3,7 @@ var $ = require('../internals/export');
 var call = require('../internals/function-call');
 var aCallable = require('../internals/a-callable');
 var anObject = require('../internals/an-object');
-var getIteratorMethod = require('../internals/get-iterator-method');
+var getIteratorMethod = require('../internals/get-iterator-method-internal');
 var createIteratorProxy = require('../internals/iterator-create-proxy');
 var IS_PURE = require('../internals/is-pure');
 

package/modules/es.iterator.drop.js

@@ -11,11 +11,23 @@ var iteratorHelperThrowsOnInvalidIterator = require('../internals/iterator-helpe
 var iteratorHelperWithoutClosingOnEarlyError = require('../internals/iterator-helper-without-closing-on-early-error');
 var IS_PURE = require('../internals/is-pure');
 
+var $RangeError = RangeError;
+var $Infinity = Infinity;
+
 var DROP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('drop', 0);
 var dropWithoutClosingOnEarlyError = !IS_PURE && !DROP_WITHOUT_THROWING_ON_INVALID_ITERATOR
   && iteratorHelperWithoutClosingOnEarlyError('drop', RangeError);
 
-var FORCED = IS_PURE || DROP_WITHOUT_THROWING_ON_INVALID_ITERATOR || dropWithoutClosingOnEarlyError;
+var FORCED = IS_PURE || DROP_WITHOUT_THROWING_ON_INVALID_ITERATOR || dropWithoutClosingOnEarlyError || !function () {
+  try {
+    // eslint-disable-next-line es/no-iterator, es/no-iterator-prototype-drop -- detection
+    Iterator.prototype.drop.call({
+      next: function () { return { done: true }; }
+    }, 0x20000000000000);
+  } catch (error) {
+    return error instanceof $RangeError;
+  }
+}();
 
 var IteratorProxy = createIteratorProxy(function () {
   var iterator = this.iterator;
@@ -40,6 +52,9 @@ $({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
     var remaining;
     try {
       remaining = toPositiveInteger(notANaN(+limit));
+      if (remaining > 0x1FFFFFFFFFFFFF && remaining !== $Infinity) {
+        throw new $RangeError('The argument should be a safe integer');
+      }
     } catch (error) {
       iteratorClose(this, 'throw', error);
     }

package/modules/es.iterator.flat-map.js

@@ -7,30 +7,28 @@ var getIteratorDirect = require('../internals/get-iterator-direct');
 var getIteratorFlattenable = require('../internals/get-iterator-flattenable');
 var createIteratorProxy = require('../internals/iterator-create-proxy');
 var iteratorClose = require('../internals/iterator-close');
+var fails = require('../internals/fails');
 var IS_PURE = require('../internals/is-pure');
 var iteratorHelperThrowsOnInvalidIterator = require('../internals/iterator-helper-throws-on-invalid-iterator');
 var iteratorHelperWithoutClosingOnEarlyError = require('../internals/iterator-helper-without-closing-on-early-error');
 
 // Should not throw an error for an iterator without `return` method. Fixed in Safari 26.2
 // https://bugs.webkit.org/show_bug.cgi?id=297532
-function throwsOnIteratorWithoutReturn() {
-  try {
-    // eslint-disable-next-line es/no-map, es/no-iterator, es/no-iterator-prototype-flatmap -- required for testing
-    var it = Iterator.prototype.flatMap.call(new Map([[4, 5]]).entries(), function (v) { return v; });
-    it.next();
-    it['return']();
-  } catch (error) {
-    return true;
-  }
-}
+var THROWS_ON_ITERATOR_WITHOUT_RETURN = !IS_PURE && fails(function () {
+  // eslint-disable-next-line es/no-array-prototype-values, es/no-iterator-prototype-flatmap, es/no-iterator-prototype-find -- testing
+  return [1].values()
+    .flatMap(function () { return [1]; })
+    .find(function () { return true; }) !== 1;
+});
 
-var FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE
+var FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !THROWS_ON_ITERATOR_WITHOUT_RETURN
   && !iteratorHelperThrowsOnInvalidIterator('flatMap', function () { /* empty */ });
-var flatMapWithoutClosingOnEarlyError = !IS_PURE && !FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR
+
+var flatMapWithoutClosingOnEarlyError = !IS_PURE && !THROWS_ON_ITERATOR_WITHOUT_RETURN && !FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR
   && iteratorHelperWithoutClosingOnEarlyError('flatMap', TypeError);
 
-var FORCED = IS_PURE || FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || flatMapWithoutClosingOnEarlyError
-  || throwsOnIteratorWithoutReturn();
+var FORCED = IS_PURE || THROWS_ON_ITERATOR_WITHOUT_RETURN || FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR
+  || flatMapWithoutClosingOnEarlyError;
 
 var IteratorProxy = createIteratorProxy(function () {
   var iterator = this.iterator;

package/modules/es.iterator.take.js

@@ -11,11 +11,23 @@ var iteratorHelperThrowsOnInvalidIterator = require('../internals/iterator-helpe
 var iteratorHelperWithoutClosingOnEarlyError = require('../internals/iterator-helper-without-closing-on-early-error');
 var IS_PURE = require('../internals/is-pure');
 
+var $RangeError = RangeError;
+var $Infinity = Infinity;
+
 var TAKE_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('take', 1);
 var takeWithoutClosingOnEarlyError = !IS_PURE && !TAKE_WITHOUT_THROWING_ON_INVALID_ITERATOR
   && iteratorHelperWithoutClosingOnEarlyError('take', RangeError);
 
-var FORCED = IS_PURE || TAKE_WITHOUT_THROWING_ON_INVALID_ITERATOR || takeWithoutClosingOnEarlyError;
+var FORCED = IS_PURE || TAKE_WITHOUT_THROWING_ON_INVALID_ITERATOR || takeWithoutClosingOnEarlyError || !function () {
+  try {
+    // eslint-disable-next-line es/no-iterator, es/no-iterator-prototype-take -- detection
+    Iterator.prototype.take.call({
+      next: function () { return { done: true }; }
+    }, 0x20000000000000);
+  } catch (error) {
+    return error instanceof $RangeError;
+  }
+}();
 
 var IteratorProxy = createIteratorProxy(function () {
   var iterator = this.iterator;
@@ -36,6 +48,9 @@ $({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
     var remaining;
     try {
       remaining = toPositiveInteger(notANaN(+limit));
+      if (remaining > 0x1FFFFFFFFFFFFF && remaining !== $Infinity) {
+        throw new $RangeError('The argument should be a safe integer');
+      }
     } catch (error) {
       iteratorClose(this, 'throw', error);
     }