core-js 3.23.4 → 3.24.1

package/actual/typed-array/index.js

@@ -3,6 +3,7 @@ require('../../modules/esnext.typed-array.find-last');
 require('../../modules/esnext.typed-array.find-last-index');
 require('../../modules/esnext.typed-array.to-reversed');
 require('../../modules/esnext.typed-array.to-sorted');
+// TODO: Remove from `core-js@4`
 require('../../modules/esnext.typed-array.to-spliced');
 require('../../modules/esnext.typed-array.with');
 

package/actual/typed-array/methods.js

@@ -3,6 +3,7 @@ require('../../modules/esnext.typed-array.find-last');
 require('../../modules/esnext.typed-array.find-last-index');
 require('../../modules/esnext.typed-array.to-reversed');
 require('../../modules/esnext.typed-array.to-sorted');
+// TODO: Remove from `core-js@4`
 require('../../modules/esnext.typed-array.to-spliced');
 require('../../modules/esnext.typed-array.with');
 

package/actual/typed-array/to-spliced.js

@@ -1 +1,2 @@
+// TODO: Remove from `core-js@4`
 require('../../modules/esnext.typed-array.to-spliced');

package/features/async-iterator/indexed.js

@@ -0,0 +1 @@
+module.exports = require('../../full/async-iterator/indexed');

package/features/iterator/indexed.js

@@ -0,0 +1 @@
+module.exports = require('../../full/iterator/indexed');

package/full/async-iterator/index.js

@@ -3,6 +3,7 @@ require('../../modules/es.object.to-string');
 require('../../modules/es.promise');
 require('../../modules/es.string.iterator');
 require('../../modules/esnext.async-iterator.constructor');
+// TODO: Remove from `core-js@4`
 require('../../modules/esnext.async-iterator.as-indexed-pairs');
 require('../../modules/esnext.async-iterator.drop');
 require('../../modules/esnext.async-iterator.every');
@@ -11,6 +12,7 @@ require('../../modules/esnext.async-iterator.find');
 require('../../modules/esnext.async-iterator.flat-map');
 require('../../modules/esnext.async-iterator.for-each');
 require('../../modules/esnext.async-iterator.from');
+require('../../modules/esnext.async-iterator.indexed');
 require('../../modules/esnext.async-iterator.map');
 require('../../modules/esnext.async-iterator.reduce');
 require('../../modules/esnext.async-iterator.some');

package/full/async-iterator/indexed.js

@@ -0,0 +1,8 @@
+require('../../modules/es.object.to-string');
+require('../../modules/es.promise');
+require('../../modules/esnext.async-iterator.constructor');
+require('../../modules/esnext.async-iterator.indexed');
+
+var entryUnbind = require('../../internals/entry-unbind');
+
+module.exports = entryUnbind('AsyncIterator', 'indexed');

package/full/index.js

@@ -258,6 +258,7 @@ require('../modules/esnext.async-iterator.find');
 require('../modules/esnext.async-iterator.flat-map');
 require('../modules/esnext.async-iterator.for-each');
 require('../modules/esnext.async-iterator.from');
+require('../modules/esnext.async-iterator.indexed');
 require('../modules/esnext.async-iterator.map');
 require('../modules/esnext.async-iterator.reduce');
 require('../modules/esnext.async-iterator.some');
@@ -279,6 +280,7 @@ require('../modules/esnext.iterator.find');
 require('../modules/esnext.iterator.flat-map');
 require('../modules/esnext.iterator.for-each');
 require('../modules/esnext.iterator.from');
+require('../modules/esnext.iterator.indexed');
 require('../modules/esnext.iterator.map');
 require('../modules/esnext.iterator.reduce');
 require('../modules/esnext.iterator.some');

package/full/iterator/index.js

@@ -3,6 +3,7 @@ require('../../modules/es.object.to-string');
 require('../../modules/es.promise');
 require('../../modules/es.string.iterator');
 require('../../modules/esnext.iterator.constructor');
+// TODO: Remove from `core-js@4`
 require('../../modules/esnext.iterator.as-indexed-pairs');
 require('../../modules/esnext.iterator.drop');
 require('../../modules/esnext.iterator.every');
@@ -11,6 +12,7 @@ require('../../modules/esnext.iterator.find');
 require('../../modules/esnext.iterator.flat-map');
 require('../../modules/esnext.iterator.for-each');
 require('../../modules/esnext.iterator.from');
+require('../../modules/esnext.iterator.indexed');
 require('../../modules/esnext.iterator.map');
 require('../../modules/esnext.iterator.reduce');
 require('../../modules/esnext.iterator.some');

package/full/iterator/indexed.js

@@ -0,0 +1,8 @@
+require('../../modules/es.object.to-string');
+require('../../modules/esnext.iterator.constructor');
+require('../../modules/esnext.iterator.indexed');
+
+var entryUnbind = require('../../internals/entry-unbind');
+
+module.exports = entryUnbind('Iterator', 'indexed');
+

package/full/typed-array/to-spliced.js

@@ -1,3 +1,4 @@
+// TODO: Remove from `core-js@4`
 var parent = require('../../actual/typed-array/to-spliced');
 
 module.exports = parent;

package/internals/async-from-sync-iterator.js

@@ -1,5 +1,5 @@
 'use strict';
-var apply = require('../internals/function-apply');
+var call = require('../internals/function-call');
 var anObject = require('../internals/an-object');
 var create = require('../internals/object-create');
 var getMethod = require('../internals/get-method');
@@ -30,31 +30,19 @@ var AsyncFromSyncIterator = function AsyncIterator(iterator) {
 };
 
 AsyncFromSyncIterator.prototype = defineBuiltIns(create(AsyncIteratorPrototype), {
-  next: function next(arg) {
+  next: function next() {
     var state = getInternalState(this);
-    var hasArg = !!arguments.length;
     return new Promise(function (resolve, reject) {
-      var result = anObject(apply(state.next, state.iterator, hasArg ? [arg] : []));
+      var result = anObject(call(state.next, state.iterator));
       asyncFromSyncIteratorContinuation(result, resolve, reject);
     });
   },
-  'return': function (arg) {
+  'return': function () {
     var iterator = getInternalState(this).iterator;
-    var hasArg = !!arguments.length;
     return new Promise(function (resolve, reject) {
       var $return = getMethod(iterator, 'return');
-      if ($return === undefined) return resolve({ done: true, value: arg });
-      var result = anObject(apply($return, iterator, hasArg ? [arg] : []));
-      asyncFromSyncIteratorContinuation(result, resolve, reject);
-    });
-  },
-  'throw': function (arg) {
-    var iterator = getInternalState(this).iterator;
-    var hasArg = !!arguments.length;
-    return new Promise(function (resolve, reject) {
-      var $throw = getMethod(iterator, 'throw');
-      if ($throw === undefined) return reject(arg);
-      var result = anObject(apply($throw, iterator, hasArg ? [arg] : []));
+      if ($return === undefined) return resolve({ done: true, value: undefined });
+      var result = anObject(call($return, iterator));
       asyncFromSyncIteratorContinuation(result, resolve, reject);
     });
   }

package/internals/async-iterator-close.js

@@ -0,0 +1,18 @@
+var call = require('../internals/function-call');
+var getBuiltIn = require('../internals/get-built-in');
+var getMethod = require('../internals/get-method');
+
+module.exports = function (iterator, method, argument, reject) {
+  try {
+    var returnMethod = getMethod(iterator, 'return');
+    if (returnMethod) {
+      return getBuiltIn('Promise').resolve(call(returnMethod, iterator)).then(function () {
+        method(argument);
+      }, function (error) {
+        reject(error);
+      });
+    }
+  } catch (error2) {
+    return reject(error2);
+  } method(argument);
+};

package/internals/async-iterator-create-proxy.js

@@ -1,5 +1,6 @@
 'use strict';
 var call = require('../internals/function-call');
+var perform = require('../internals/perform');
 var anObject = require('../internals/an-object');
 var create = require('../internals/object-create');
 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
@@ -9,68 +10,118 @@ 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 iteratorClose = require('../internals/iterator-close');
 
 var Promise = getBuiltIn('Promise');
 
-var ASYNC_ITERATOR_PROXY = 'AsyncIteratorProxy';
+var ASYNC_ITERATOR_HELPER = 'AsyncIteratorHelper';
+var WRAP_FOR_VALID_ASYNC_ITERATOR = 'WrapForValidAsyncIterator';
 var setInternalState = InternalStateModule.set;
-var getInternalState = InternalStateModule.getterFor(ASYNC_ITERATOR_PROXY);
 
 var TO_STRING_TAG = wellKnownSymbol('toStringTag');
 
+var createAsyncIteratorProxyPrototype = function (IS_ITERATOR) {
+  var IS_GENERATOR = !IS_ITERATOR;
+  var ASYNC_ITERATOR_PROXY = IS_ITERATOR ? WRAP_FOR_VALID_ASYNC_ITERATOR : ASYNC_ITERATOR_HELPER;
+
+  var getInternalState = InternalStateModule.getterFor(ASYNC_ITERATOR_PROXY);
+
+  var getStateOrEarlyExit = function (that) {
+    var stateCompletion = perform(function () {
+      return getInternalState(that);
+    });
+
+    var stateError = stateCompletion.error;
+    var state = stateCompletion.value;
+
+    if (stateError || (IS_GENERATOR && state.done)) {
+      return { exit: true, value: stateError ? Promise.reject(state) : Promise.resolve({ done: true, value: undefined }) };
+    } return { exit: false, value: state };
+  };
+
+  var enqueue = function (state, handler) {
+    var task = function () {
+      var promise = handler();
+      if (IS_GENERATOR) {
+        state.awaiting = promise;
+        var clean = function () {
+          if (state.awaiting === promise) state.awaiting = null;
+        };
+        promise.then(clean, clean);
+      } return promise;
+    };
+
+    return state.awaiting ? state.awaiting = state.awaiting.then(task, task) : task();
+  };
+
+  var AsyncIteratorProxyPrototype = defineBuiltIns(create(AsyncIteratorPrototype), {
+    next: function next() {
+      var stateCompletion = getStateOrEarlyExit(this);
+      var exit = stateCompletion.exit;
+      var state = stateCompletion.value;
+
+      return exit ? state : enqueue(state, function () {
+        var handlerCompletion = perform(function () {
+          return anObject(state.nextHandler(Promise));
+        });
+        var handlerError = handlerCompletion.error;
+        var value = handlerCompletion.value;
+        if (handlerError) state.done = true;
+        return handlerError ? Promise.reject(value) : Promise.resolve(value);
+      });
+    },
+    'return': function () {
+      var stateCompletion = getStateOrEarlyExit(this);
+      var exit = stateCompletion.exit;
+      var state = stateCompletion.value;
+
+      return exit ? state : enqueue(state, function () {
+        return new Promise(function (resolve, reject) {
+          var iterator = state.iterator;
+          var innerIterator = state.innerIterator;
+          state.done = true;
+          if (innerIterator) try {
+            iteratorClose(innerIterator, 'return');
+          } catch (error) {
+            return iteratorClose(iterator, 'throw', error);
+          }
+          var $$return = getMethod(iterator, 'return');
+          if ($$return === undefined) return resolve({ done: true, value: undefined });
+          Promise.resolve(call($$return, iterator)).then(function (result) {
+            anObject(result);
+            resolve({ done: true, value: undefined });
+          }, reject);
+        });
+      });
+    }
+  });
+
+  if (IS_GENERATOR) {
+    createNonEnumerableProperty(AsyncIteratorProxyPrototype, TO_STRING_TAG, 'Async Iterator Helper');
+  }
+
+  return AsyncIteratorProxyPrototype;
+};
+
+var AsyncIteratorHelperPrototype = createAsyncIteratorProxyPrototype(false);
+var WrapForValidAsyncIteratorPrototype = createAsyncIteratorProxyPrototype(true);
+
 module.exports = function (nextHandler, IS_ITERATOR) {
+  var ASYNC_ITERATOR_PROXY = IS_ITERATOR ? WRAP_FOR_VALID_ASYNC_ITERATOR : ASYNC_ITERATOR_HELPER;
+
   var AsyncIteratorProxy = function AsyncIterator(record, state) {
     if (state) {
       state.iterator = record.iterator;
       state.next = record.next;
     } else state = record;
     state.type = ASYNC_ITERATOR_PROXY;
+    state.nextHandler = nextHandler;
     state.done = false;
-    state.ignoreArgument = !IS_ITERATOR;
+    state.awaiting = null;
     setInternalState(this, state);
   };
 
-  AsyncIteratorProxy.prototype = defineBuiltIns(create(AsyncIteratorPrototype), {
-    next: function next(arg) {
-      var that = this;
-      var hasArgument = !!arguments.length;
-      return new Promise(function (resolve) {
-        var state = getInternalState(that);
-        var args = hasArgument ? [state.ignoreArgument ? undefined : arg] : IS_ITERATOR ? [] : [undefined];
-        state.ignoreArgument = false;
-        resolve(state.done ? { done: true, value: undefined } : anObject(call(nextHandler, state, Promise, args)));
-      });
-    },
-    'return': function (value) {
-      var that = this;
-      return new Promise(function (resolve, reject) {
-        var state = getInternalState(that);
-        var iterator = state.iterator;
-        state.done = true;
-        var $$return = getMethod(iterator, 'return');
-        if ($$return === undefined) return resolve({ done: true, value: value });
-        Promise.resolve(call($$return, iterator, value)).then(function (result) {
-          anObject(result);
-          resolve({ done: true, value: value });
-        }, reject);
-      });
-    },
-    'throw': function (value) {
-      var that = this;
-      return new Promise(function (resolve, reject) {
-        var state = getInternalState(that);
-        var iterator = state.iterator;
-        state.done = true;
-        var $$throw = getMethod(iterator, 'throw');
-        if ($$throw === undefined) return reject(value);
-        resolve(call($$throw, iterator, value));
-      });
-    }
-  });
-
-  if (!IS_ITERATOR) {
-    createNonEnumerableProperty(AsyncIteratorProxy.prototype, TO_STRING_TAG, 'Generator');
-  }
+  AsyncIteratorProxy.prototype = IS_ITERATOR ? WrapForValidAsyncIteratorPrototype : AsyncIteratorHelperPrototype;
 
   return AsyncIteratorProxy;
 };

package/internals/async-iterator-indexed.js

@@ -0,0 +1,28 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var call = require('../internals/function-call');
+var anObject = require('../internals/an-object');
+var getIteratorDirect = require('../internals/get-iterator-direct');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+
+var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise) {
+  var state = this;
+  var iterator = state.iterator;
+
+  return Promise.resolve(anObject(call(state.next, iterator))).then(function (step) {
+    if (anObject(step).done) {
+      state.done = true;
+      return { done: true, value: undefined };
+    }
+    return { done: false, value: [state.index++, step.value] };
+  }).then(null, function (error) {
+    state.done = true;
+    throw error;
+  });
+});
+
+module.exports = function indexed() {
+  return new AsyncIteratorProxy(getIteratorDirect(this), {
+    index: 0
+  });
+};

package/internals/async-iterator-iteration.js

@@ -7,7 +7,7 @@ var anObject = require('../internals/an-object');
 var doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');
 var getBuiltIn = require('../internals/get-built-in');
 var getIteratorDirect = require('../internals/get-iterator-direct');
-var getMethod = require('../internals/get-method');
+var closeAsyncIteration = require('../internals/async-iterator-close');
 
 var createMethod = function (TYPE) {
   var IS_TO_ARRAY = TYPE == 0;
@@ -24,28 +24,15 @@ var createMethod = function (TYPE) {
     if (MAPPING || !IS_TO_ARRAY) aCallable(fn);
 
     return new Promise(function (resolve, reject) {
-      var closeIteration = function (method, argument) {
-        try {
-          var returnMethod = getMethod(iterator, 'return');
-          if (returnMethod) {
-            return Promise.resolve(call(returnMethod, iterator)).then(function () {
-              method(argument);
-            }, function (error) {
-              reject(error);
-            });
-          }
-        } catch (error2) {
-          return reject(error2);
-        } method(argument);
-      };
-
-      var onError = function (error) {
-        closeIteration(reject, error);
+      var ifAbruptCloseAsyncIterator = function (error) {
+        closeAsyncIteration(iterator, reject, error, reject);
       };
 
       var loop = function () {
         try {
-          if (IS_TO_ARRAY && MAPPING) doesNotExceedSafeInteger(index);
+          if (IS_TO_ARRAY && MAPPING) try {
+            doesNotExceedSafeInteger(index);
+          } catch (error5) { ifAbruptCloseAsyncIterator(error5); }
           Promise.resolve(anObject(call(next, iterator))).then(function (step) {
             try {
               if (anObject(step).done) {
@@ -55,27 +42,31 @@ var createMethod = function (TYPE) {
                 } else resolve(IS_SOME ? false : IS_EVERY || undefined);
               } else {
                 var value = step.value;
-                if (MAPPING) {
-                  Promise.resolve(IS_TO_ARRAY ? fn(value, index) : fn(value)).then(function (result) {
-                    if (IS_FOR_EACH) {
-                      loop();
-                    } else if (IS_EVERY) {
-                      result ? loop() : closeIteration(resolve, false);
-                    } else if (IS_TO_ARRAY) {
-                      target[index++] = result;
-                      loop();
-                    } else {
-                      result ? closeIteration(resolve, IS_SOME || value) : loop();
-                    }
-                  }, onError);
-                } else {
-                  target[index++] = value;
-                  loop();
-                }
+                try {
+                  if (MAPPING) {
+                    Promise.resolve(IS_TO_ARRAY ? fn(value, index) : fn(value)).then(function (result) {
+                      if (IS_FOR_EACH) {
+                        loop();
+                      } else if (IS_EVERY) {
+                        result ? loop() : closeAsyncIteration(iterator, resolve, false, reject);
+                      } else if (IS_TO_ARRAY) {
+                        try {
+                          target[index++] = result;
+                          loop();
+                        } catch (error4) { ifAbruptCloseAsyncIterator(error4); }
+                      } else {
+                        result ? closeAsyncIteration(iterator, resolve, IS_SOME || value, reject) : loop();
+                      }
+                    }, ifAbruptCloseAsyncIterator);
+                  } else {
+                    target[index++] = value;
+                    loop();
+                  }
+                } catch (error3) { ifAbruptCloseAsyncIterator(error3); }
               }
-            } catch (error) { onError(error); }
-          }, onError);
-        } catch (error2) { onError(error2); }
+            } catch (error2) { reject(error2); }
+          }, reject);
+        } catch (error) { reject(error); }
       };
 
       loop();

package/internals/async-iterator-wrap.js

@@ -0,0 +1,6 @@
+var call = require('../internals/function-call');
+var createAsyncIteratorProxy = require('../internals/async-iterator-create-proxy');
+
+module.exports = createAsyncIteratorProxy(function () {
+  return call(this.next, this.iterator);
+}, true);

package/internals/engine-is-browser.js

@@ -1 +1,6 @@
-module.exports = typeof window == 'object' && typeof Deno != 'object';
+var IS_DENO = require('../internals/engine-is-deno');
+var IS_NODE = require('../internals/engine-is-node');
+
+module.exports = !IS_DENO && !IS_NODE
+  && typeof window == 'object'
+  && typeof document == 'object';

package/internals/iterator-create-proxy.js

@@ -8,53 +8,74 @@ var wellKnownSymbol = require('../internals/well-known-symbol');
 var InternalStateModule = require('../internals/internal-state');
 var getMethod = require('../internals/get-method');
 var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;
+var iteratorClose = require('../internals/iterator-close');
 
-var ITERATOR_PROXY = 'IteratorProxy';
+var ITERATOR_HELPER = 'IteratorHelper';
+var WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator';
 var setInternalState = InternalStateModule.set;
-var getInternalState = InternalStateModule.getterFor(ITERATOR_PROXY);
 
 var TO_STRING_TAG = wellKnownSymbol('toStringTag');
 
-module.exports = function (nextHandler, IS_ITERATOR) {
-  var IteratorProxy = function Iterator(record, state) {
-    if (state) {
-      state.iterator = record.iterator;
-      state.next = record.next;
-    } else state = record;
-    state.type = ITERATOR_PROXY;
-    state.done = false;
-    state.ignoreArg = !IS_ITERATOR;
-    setInternalState(this, state);
-  };
+var createIteratorProxyPrototype = function (IS_ITERATOR) {
+  var ITERATOR_PROXY = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
 
-  IteratorProxy.prototype = defineBuiltIns(create(IteratorPrototype), {
-    next: function next(arg) {
+  var getInternalState = InternalStateModule.getterFor(ITERATOR_PROXY);
+
+  var IteratorProxyPrototype = defineBuiltIns(create(IteratorPrototype), {
+    next: function next() {
       var state = getInternalState(this);
-      var args = arguments.length ? [state.ignoreArg ? undefined : arg] : IS_ITERATOR ? [] : [undefined];
-      state.ignoreArg = false;
-      var result = state.done ? undefined : call(nextHandler, state, args);
-      return { done: state.done, value: result };
+      // for simplification:
+      //   for `%WrapForValidIteratorPrototype%.next` our `nextHandler` returns `IterResultObject`
+      //   for `%IteratorHelperPrototype%.next` - just a value
+      if (IS_ITERATOR) return state.nextHandler();
+      try {
+        var result = state.done ? undefined : state.nextHandler();
+        return { done: state.done, value: result };
+      } catch (error) {
+        state.done = true;
+        throw error;
+      }
     },
-    'return': function (value) {
+    'return': function () {
       var state = getInternalState(this);
       var iterator = state.iterator;
+      var innerIterator = state.innerIterator;
       state.done = true;
+      if (innerIterator) try {
+        iteratorClose(innerIterator, 'return');
+      } catch (error) {
+        return iteratorClose(iterator, 'throw', error);
+      }
       var $$return = getMethod(iterator, 'return');
-      return { done: true, value: $$return ? anObject(call($$return, iterator, value)).value : value };
-    },
-    'throw': function (value) {
-      var state = getInternalState(this);
-      var iterator = state.iterator;
-      state.done = true;
-      var $$throw = getMethod(iterator, 'throw');
-      if ($$throw) return call($$throw, iterator, value);
-      throw value;
+      return { done: true, value: $$return ? anObject(call($$return, iterator)).value : undefined };
     }
   });
 
   if (!IS_ITERATOR) {
-    createNonEnumerableProperty(IteratorProxy.prototype, TO_STRING_TAG, 'Generator');
+    createNonEnumerableProperty(IteratorProxyPrototype, TO_STRING_TAG, 'Iterator Helper');
   }
 
+  return IteratorProxyPrototype;
+};
+
+var IteratorHelperPrototype = createIteratorProxyPrototype(false);
+var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
+
+module.exports = function (nextHandler, IS_ITERATOR) {
+  var ITERATOR_PROXY = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
+
+  var IteratorProxy = function Iterator(record, state) {
+    if (state) {
+      state.iterator = record.iterator;
+      state.next = record.next;
+    } else state = record;
+    state.type = ITERATOR_PROXY;
+    state.nextHandler = nextHandler;
+    state.done = false;
+    setInternalState(this, state);
+  };
+
+  IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;
+
   return IteratorProxy;
 };

package/internals/iterator-indexed.js

@@ -0,0 +1,18 @@
+'use strict';
+// https://github.com/tc39/proposal-iterator-helpers
+var call = require('../internals/function-call');
+var anObject = require('../internals/an-object');
+var getIteratorDirect = require('../internals/get-iterator-direct');
+var createIteratorProxy = require('../internals/iterator-create-proxy');
+
+var IteratorProxy = createIteratorProxy(function () {
+  var result = anObject(call(this.next, this.iterator));
+  var done = this.done = !!result.done;
+  if (!done) return [this.index++, result.value];
+});
+
+module.exports = function indexed() {
+  return new IteratorProxy(getIteratorDirect(this), {
+    index: 0
+  });
+};

package/internals/not-a-nan.js

@@ -0,0 +1,7 @@
+var $RangeError = RangeError;
+
+module.exports = function (it) {
+  // eslint-disable-next-line no-self-compare -- NaN check
+  if (it === it) return it;
+  throw $RangeError('NaN is not allowed');
+};

package/internals/promise-constructor-detection.js

@@ -5,6 +5,7 @@ var isForced = require('../internals/is-forced');
 var inspectSource = require('../internals/inspect-source');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 var IS_BROWSER = require('../internals/engine-is-browser');
+var IS_DENO = require('../internals/engine-is-deno');
 var IS_PURE = require('../internals/is-pure');
 var V8_VERSION = require('../internals/engine-v8-version');
 
@@ -25,18 +26,18 @@ var FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {
   // We can't use @@species feature detection in V8 since it causes
   // deoptimization and performance degradation
   // https://github.com/zloirock/core-js/issues/679
-  if (V8_VERSION >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false;
-  // Detect correctness of subclassing with @@species support
-  var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });
-  var FakePromise = function (exec) {
-    exec(function () { /* empty */ }, function () { /* empty */ });
-  };
-  var constructor = promise.constructor = {};
-  constructor[SPECIES] = FakePromise;
-  SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
-  if (!SUBCLASSING) return true;
+  if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
+    // Detect correctness of subclassing with @@species support
+    var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });
+    var FakePromise = function (exec) {
+      exec(function () { /* empty */ }, function () { /* empty */ });
+    };
+    var constructor = promise.constructor = {};
+    constructor[SPECIES] = FakePromise;
+    SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
+    if (!SUBCLASSING) return true;
   // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
-  return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_PROMISE_REJECTION_EVENT;
+  } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;
 });
 
 module.exports = {