lib: add Iterator global to primordials

Signed-off-by: Renegade334 <contact.9a5d6388@renegade334.me.uk>

Author: Renegade334

lib/eslint.config_partial.mjs

@@ -164,10 +164,6 @@ export default [
           name: 'Intl',
           message: 'Use `const { Intl } = globalThis;` instead of the global.',
         },
-        {
-          name: 'Iterator',
-          message: 'Use `const { Iterator } = globalThis;` instead of the global.',
-        },
         {
           name: 'MessageChannel',
           message: "Use `const { MessageChannel } = require('internal/worker/io');` instead of the global.",
@@ -464,6 +460,7 @@ export default [
         { name: 'Int16Array' },
         { name: 'Int32Array' },
         { name: 'Int8Array' },
+        { name: 'Iterator' },
         {
           name: 'isFinite',
           into: 'Number',

lib/internal/per_context/primordials.js

@@ -202,6 +202,7 @@ function copyPrototype(src, dest, prefix) {
   'Int16Array',
   'Int32Array',
   'Int8Array',
+  'Iterator',
   'Map',
   'Number',
   'Object',
@@ -230,10 +231,10 @@ function copyPrototype(src, dest, prefix) {
 });
 
 
-// Create copies of intrinsic objects that require a valid `this` to call
-// static methods.
-// Refs: https://www.ecma-international.org/ecma-262/#sec-promise.all
+// Create copies of intrinsic objects whose static methods require the
+// constructor to be passed as the receiver.
 [
+  // Refs: https://tc39.es/ecma-262/#sec-promise.all
   'Promise',
 ].forEach((name) => {
   // eslint-disable-next-line no-restricted-globals
@@ -244,25 +245,36 @@ function copyPrototype(src, dest, prefix) {
 });
 
 // Create copies of abstract intrinsic objects that are not directly exposed
-// on the global object.
-// Refs: https://tc39.es/ecma262/#sec-%typedarray%-intrinsic-object
+// on the global object, and whose static methods require a valid subclass
+// constructor to be passed as the receiver.
 [
+  // Refs: https://tc39.es/ecma262/#sec-%typedarray%-intrinsic-object
   { name: 'TypedArray', original: Reflect.getPrototypeOf(Uint8Array) },
-  { name: 'ArrayIterator', original: {
-    prototype: Reflect.getPrototypeOf(Array.prototype[Symbol.iterator]()),
-  } },
-  { name: 'StringIterator', original: {
-    prototype: Reflect.getPrototypeOf(String.prototype[Symbol.iterator]()),
-  } },
 ].forEach(({ name, original }) => {
   primordials[name] = original;
-  // The static %TypedArray% methods require a valid `this`, but can't be bound,
-  // as they need a subclass constructor as the receiver:
   copyPrototype(original, primordials, name);
   copyPrototype(original.prototype, primordials, `${name}Prototype`);
 });
 
-primordials.IteratorPrototype = Reflect.getPrototypeOf(primordials.ArrayIteratorPrototype);
+// Create copies of abstract intrinsic prototypes that are not directly exposed
+// on the global object and which do not have corresponding constructors.
+[
+  {
+    name: 'ArrayIteratorPrototype',
+    original: Reflect.getPrototypeOf(Array.prototype[Symbol.iterator]()),
+  },
+  {
+    name: 'AsyncIteratorPrototype',
+    original: Reflect.getPrototypeOf(Reflect.getPrototypeOf(async function*() {}).prototype),
+  },
+  {
+    name: 'StringIteratorPrototype',
+    original: Reflect.getPrototypeOf(String.prototype[Symbol.iterator]()),
+  },
+].forEach(({ name, original }) => {
+  primordials[name] = original;
+  copyPrototype(original, primordials, name);
+});
 
 /* eslint-enable node-core/prefer-primordials */
 
@@ -453,11 +465,6 @@ primordials.SafePromisePrototypeFinally = (thisPromise, onFinally) =>
       .then(a, b),
   );
 
-primordials.AsyncIteratorPrototype =
-  primordials.ReflectGetPrototypeOf(
-    primordials.ReflectGetPrototypeOf(
-      async function* () {}).prototype);
-
 const arrayToSafePromiseIterable = (promises, mapFn) =>
   new primordials.SafeArrayIterator(
     ArrayPrototypeMap(

typings/primordials.d.ts

@@ -545,6 +545,21 @@ declare namespace primordials {
   export const PromisePrototypeFinally: UncurryThis<typeof Promise.prototype.finally>
   export const PromiseWithResolvers: typeof Promise.withResolvers
   export import Proxy = globalThis.Proxy
+  export import Iterator = globalThis.Iterator
+  export const IteratorFrom: typeof Iterator.from
+  export const IteratorPrototype: typeof Iterator.prototype
+  export const IteratorPrototypeDrop: UncurryThis<typeof Iterator.prototype.drop>
+  export const IteratorPrototypeEvery: UncurryThis<typeof Iterator.prototype.every>
+  export const IteratorPrototypeFilter: UncurryThis<typeof Iterator.prototype.filter>
+  export const IteratorPrototypeFind: UncurryThis<typeof Iterator.prototype.find>
+  export const IteratorPrototypeFlatMap: UncurryThis<typeof Iterator.prototype.flatMap>
+  export const IteratorPrototypeForEach: UncurryThis<typeof Iterator.prototype.forEach>
+  export const IteratorPrototypeMap: UncurryThis<typeof Iterator.prototype.map>
+  export const IteratorPrototypeReduce: UncurryThis<typeof Iterator.prototype.reduce>
+  export const IteratorPrototypeSome: UncurryThis<typeof Iterator.prototype.some>
+  export const IteratorPrototypeTake: UncurryThis<typeof Iterator.prototype.take>
+  export const IteratorPrototypeToArray: UncurryThis<typeof Iterator.prototype.toArray>
+  export const IteratorPrototypeSymbolIterator: UncurryMethod<typeof Iterator.prototype, typeof Symbol.iterator>
   import _globalThis = globalThis
   export { _globalThis as globalThis }
 }