Repository: eslint-community/eslint-plugin-es-x
Pull request #211 (2024-10-31 08:16:05)

Add `no-iterator-helpers` rules
This PR adds the following rules:

- `es-x/no-iterator`
- `es-x/no-iterator-prototype-drop`
- `es-x/no-iterator-prototype-every`
- `es-x/no-iterator-prototype-filter`
- `es-x/no-iterator-prototype-find`
- `es-x/no-iterator-prototype-flatmap`
- `es-x/no-iterator-prototype-foreach`
- `es-x/no-iterator-prototype-map`
- `es-x/no-iterator-prototype-reduce`
- `es-x/no-iterator-prototype-some`
- `es-x/no-iterator-prototype-take`
- `es-x/no-iterator-prototype-toarray`

This PR also adds the `no-iterator-helpers` config


related to https://github.com/eslint-community/eslint-plugin-es-x/issues/201


Patch:
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 97b66d4..2bf8d04 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -3,4 +3,5 @@
         "javascript",
         "vue"
     ],
+    "typescript.tsdk": "node_modules/typescript/lib",
 }
diff --git a/docs/configs/index.md b/docs/configs/index.md
index dd99256..dfd2cdd 100644
--- a/docs/configs/index.md
+++ b/docs/configs/index.md
@@ -1031,6 +1031,34 @@ export default [
 }
 ```
 
+## no-iterator-helpers
+
+disallow proposal ES2025 [Iterator Helpers](https://github.com/tc39/proposal-iterator-helpers)\
+⚠️ This config will be changed in the minor versions of this plugin.
+
+This configs includes rules for [es-x/no-iterator-prototype-drop](../rules/no-iterator-prototype-drop.md), [es-x/no-iterator-prototype-every](../rules/no-iterator-prototype-every.md), [es-x/no-iterator-prototype-filter](../rules/no-iterator-prototype-filter.md), [es-x/no-iterator-prototype-find](../rules/no-iterator-prototype-find.md), [es-x/no-iterator-prototype-flatmap](../rules/no-iterator-prototype-flatmap.md), [es-x/no-iterator-prototype-foreach](../rules/no-iterator-prototype-foreach.md), [es-x/no-iterator-prototype-map](../rules/no-iterator-prototype-map.md), [es-x/no-iterator-prototype-reduce](../rules/no-iterator-prototype-reduce.md), [es-x/no-iterator-prototype-some](../rules/no-iterator-prototype-some.md), [es-x/no-iterator-prototype-take](../rules/no-iterator-prototype-take.md), [es-x/no-iterator-prototype-toarray](../rules/no-iterator-prototype-toarray.md), and [es-x/no-iterator](../rules/no-iterator.md).
+
+### [Config (Flat Config)]
+
+eslint.config.js:
+
+```js
+import pluginESx from "eslint-plugin-es-x"
+export default [
+    pluginESx.configs['flat/no-iterator-helpers']
+]
+```
+
+### [Legacy Config]
+
+.eslintrc.*:
+
+```json
+{
+    "extends": ["plugin:es-x/no-iterator-helpers"],
+}
+```
+
 ## no-set-methods
 
 disallow proposal ES2025 [Set Methods for JavaScript](https://github.com/tc39/proposal-set-methods)\
diff --git a/docs/rules/index.md b/docs/rules/index.md
index fceeb4b..a670ed7 100644
--- a/docs/rules/index.md
+++ b/docs/rules/index.md
@@ -10,9 +10,22 @@ There is a config that enables the rules in this category: [`no-new-in-esnext`]
 
 | Rule ID | Description |    |
 |:--------|:------------|:--:|
-| [es-x/no-dynamic-import-options](./no-dynamic-import-options.md) | disallow second parameter to `import()`. |  |
+| [es-x/no-dynamic-import-options](./no-dynamic-import-options.md) | disallow the second parameter to `import()`. |  |
 | [es-x/no-import-attributes](./no-import-attributes.md) | disallow Import Attributes. |  |
+| [es-x/no-iterator-prototype-drop](./no-iterator-prototype-drop.md) | disallow the `Iterator.prototype.drop` method. |  |
+| [es-x/no-iterator-prototype-every](./no-iterator-prototype-every.md) | disallow the `Iterator.prototype.every` method. |  |
+| [es-x/no-iterator-prototype-filter](./no-iterator-prototype-filter.md) | disallow the `Iterator.prototype.filter` method. |  |
+| [es-x/no-iterator-prototype-find](./no-iterator-prototype-find.md) | disallow the `Iterator.prototype.find` method. |  |
+| [es-x/no-iterator-prototype-flatmap](./no-iterator-prototype-flatmap.md) | disallow the `Iterator.prototype.flatMap` method. |  |
+| [es-x/no-iterator-prototype-foreach](./no-iterator-prototype-foreach.md) | disallow the `Iterator.prototype.forEach` method. |  |
+| [es-x/no-iterator-prototype-map](./no-iterator-prototype-map.md) | disallow the `Iterator.prototype.map` method. |  |
+| [es-x/no-iterator-prototype-reduce](./no-iterator-prototype-reduce.md) | disallow the `Iterator.prototype.reduce` method. |  |
+| [es-x/no-iterator-prototype-some](./no-iterator-prototype-some.md) | disallow the `Iterator.prototype.some` method. |  |
+| [es-x/no-iterator-prototype-take](./no-iterator-prototype-take.md) | disallow the `Iterator.prototype.take` method. |  |
+| [es-x/no-iterator-prototype-toarray](./no-iterator-prototype-toarray.md) | disallow the `Iterator.prototype.toArray` method. |  |
+| [es-x/no-iterator](./no-iterator.md) | disallow the `Iterator` class. |  |
 | [es-x/no-json-modules](./no-json-modules.md) | disallow JSON Modules. |  |
+| [es-x/no-promise-try](./no-promise-try.md) | disallow `Promise.try` function. |  |
 | [es-x/no-regexp-duplicate-named-capturing-groups](./no-regexp-duplicate-named-capturing-groups.md) | disallow RegExp duplicate named capturing groups. |  |
 | [es-x/no-regexp-modifiers](./no-regexp-modifiers.md) | disallow RegExp Modifiers. |  |
 | [es-x/no-set-prototype-difference](./no-set-prototype-difference.md) | disallow the `Set.prototype.difference` method. |  |
diff --git a/docs/rules/no-dynamic-import-options.md b/docs/rules/no-dynamic-import-options.md
index 3530ba0..560b7c1 100644
--- a/docs/rules/no-dynamic-import-options.md
+++ b/docs/rules/no-dynamic-import-options.md
@@ -1,10 +1,10 @@
 ---
 title: "es-x/no-dynamic-import-options"
-description: "disallow second parameter to `import()`"
+description: "disallow the second parameter to `import()`"
 ---
 
 # es-x/no-dynamic-import-options
-> disallow second parameter to `import()`
+> disallow the second parameter to `import()`
 
 - ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
 - ✅ The following configurations enable this rule: [no-import-attributes] and [no-new-in-esnext]
diff --git a/docs/rules/no-iterator-prototype-drop.md b/docs/rules/no-iterator-prototype-drop.md
new file mode 100644
index 0000000..bd57c76
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-drop.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-drop"
+description: "disallow the `Iterator.prototype.drop` method"
+---
+
+# es-x/no-iterator-prototype-drop
+> disallow the `Iterator.prototype.drop` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.drop`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-drop: error */
+const result = naturals()
+  .drop(3);
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-drop.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-drop.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator-prototype-every.md b/docs/rules/no-iterator-prototype-every.md
new file mode 100644
index 0000000..ca6efdd
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-every.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-every"
+description: "disallow the `Iterator.prototype.every` method"
+---
+
+# es-x/no-iterator-prototype-every
+> disallow the `Iterator.prototype.every` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.every`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-every: error */
+const result = naturals()
+  .every(n => n % 2);
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-every.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-every.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator-prototype-filter.md b/docs/rules/no-iterator-prototype-filter.md
new file mode 100644
index 0000000..7e4cf85
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-filter.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-filter"
+description: "disallow the `Iterator.prototype.filter` method"
+---
+
+# es-x/no-iterator-prototype-filter
+> disallow the `Iterator.prototype.filter` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.filter`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-filter: error */
+const result = naturals()
+  .filter(n => n % 2);
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-filter.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-filter.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator-prototype-find.md b/docs/rules/no-iterator-prototype-find.md
new file mode 100644
index 0000000..85ad3d4
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-find.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-find"
+description: "disallow the `Iterator.prototype.find` method"
+---
+
+# es-x/no-iterator-prototype-find
+> disallow the `Iterator.prototype.find` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.find`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-find: error */
+const result = naturals()
+  .find(n => n % 2);
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-find.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-find.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator-prototype-flatmap.md b/docs/rules/no-iterator-prototype-flatmap.md
new file mode 100644
index 0000000..148f2ae
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-flatmap.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-flatmap"
+description: "disallow the `Iterator.prototype.flatMap` method"
+---
+
+# es-x/no-iterator-prototype-flatmap
+> disallow the `Iterator.prototype.flatMap` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.flatMap`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-flatmap: error */
+const result = naturals()
+  .flatMap(n => [n, -n]);
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-flatmap.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-flatmap.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator-prototype-foreach.md b/docs/rules/no-iterator-prototype-foreach.md
new file mode 100644
index 0000000..4e956b3
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-foreach.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-foreach"
+description: "disallow the `Iterator.prototype.forEach` method"
+---
+
+# es-x/no-iterator-prototype-foreach
+> disallow the `Iterator.prototype.forEach` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.forEach`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-foreach: error */
+const result = naturals()
+  .forEach(n => {/* ... */});
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-foreach.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-foreach.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator-prototype-map.md b/docs/rules/no-iterator-prototype-map.md
new file mode 100644
index 0000000..ea8120a
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-map.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-map"
+description: "disallow the `Iterator.prototype.map` method"
+---
+
+# es-x/no-iterator-prototype-map
+> disallow the `Iterator.prototype.map` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.map`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-map: error */
+const result = naturals()
+  .map(n => n % 2);
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-map.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-map.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator-prototype-reduce.md b/docs/rules/no-iterator-prototype-reduce.md
new file mode 100644
index 0000000..c3286cc
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-reduce.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-reduce"
+description: "disallow the `Iterator.prototype.reduce` method"
+---
+
+# es-x/no-iterator-prototype-reduce
+> disallow the `Iterator.prototype.reduce` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.reduce`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-reduce: error */
+const result = naturals()
+  .reduce((sum, value) => sum + value, 3);
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-reduce.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-reduce.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator-prototype-some.md b/docs/rules/no-iterator-prototype-some.md
new file mode 100644
index 0000000..e757b04
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-some.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-some"
+description: "disallow the `Iterator.prototype.some` method"
+---
+
+# es-x/no-iterator-prototype-some
+> disallow the `Iterator.prototype.some` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.some`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-some: error */
+const result = naturals()
+  .some(n => n % 2);
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-some.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-some.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator-prototype-take.md b/docs/rules/no-iterator-prototype-take.md
new file mode 100644
index 0000000..fedd16e
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-take.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-take"
+description: "disallow the `Iterator.prototype.take` method"
+---
+
+# es-x/no-iterator-prototype-take
+> disallow the `Iterator.prototype.take` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.take`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-take: error */
+const result = naturals()
+  .take(3);
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-take.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-take.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator-prototype-toarray.md b/docs/rules/no-iterator-prototype-toarray.md
new file mode 100644
index 0000000..8f584d0
--- /dev/null
+++ b/docs/rules/no-iterator-prototype-toarray.md
@@ -0,0 +1,38 @@
+---
+title: "es-x/no-iterator-prototype-toarray"
+description: "disallow the `Iterator.prototype.toArray` method"
+---
+
+# es-x/no-iterator-prototype-toarray
+> disallow the `Iterator.prototype.toArray` method
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 [`Iterator.prototype.toArray`](https://github.com/tc39/proposal-iterator-helpers) as errors.\
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator-prototype-toarray: error */
+const result = naturals()
+  .toArray();
+
+function* naturals() {
+  // ...
+}
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator-prototype-toarray.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator-prototype-toarray.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-iterator.md b/docs/rules/no-iterator.md
new file mode 100644
index 0000000..f282697
--- /dev/null
+++ b/docs/rules/no-iterator.md
@@ -0,0 +1,34 @@
+---
+title: "es-x/no-iterator"
+description: "disallow the `Iterator` class"
+---
+
+# es-x/no-iterator
+> disallow the `Iterator` class
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-iterator-helpers] and [no-new-in-esnext]
+
+This rule reports ES2025 `Iterator` class as errors.\
+The `Iterator` class was added in the ES2025 [Iterator Helpers proposal](https://github.com/tc39/proposal-iterator-helpers).
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-iterator: error */
+const wrapper = Iterator.from(iter);
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-iterator.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-iterator.js)
+
+[no-iterator-helpers]: ../configs/index.md#no-iterator-helpers
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/docs/rules/no-promise-try.md b/docs/rules/no-promise-try.md
new file mode 100644
index 0000000..65c0444
--- /dev/null
+++ b/docs/rules/no-promise-try.md
@@ -0,0 +1,32 @@
+---
+title: "es-x/no-promise-try"
+description: "disallow `Promise.try` function"
+---
+
+# es-x/no-promise-try
+> disallow `Promise.try` function
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: [no-new-in-esnext]
+
+This rule reports ES2025 [`Promise.try`](https://github.com/tc39/proposal-promise-try) as errors.
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-promise-try: error */
+const p = Promise.try(f)
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-promise-try.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-promise-try.js)
+
+[no-new-in-esnext]: ../configs/index.md#no-new-in-esnext
diff --git a/jsconfig.json b/jsconfig.json
new file mode 100644
index 0000000..99293e9
--- /dev/null
+++ b/jsconfig.json
@@ -0,0 +1,7 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "strict": true,
+        "strictNullChecks": true
+    },
+}
\ No newline at end of file
diff --git a/lib/configs/flat/no-iterator-helpers.js b/lib/configs/flat/no-iterator-helpers.js
new file mode 100644
index 0000000..b33e107
--- /dev/null
+++ b/lib/configs/flat/no-iterator-helpers.js
@@ -0,0 +1,27 @@
+/**
+ * DON'T EDIT THIS FILE.
+ * This file was generated by "scripts/update-lib-flat-configs.js" script.
+ */
+"use strict"
+
+module.exports = {
+    plugins: {
+        get "es-x"() {
+            return require("../../index.js")
+        },
+    },
+    rules: {
+        "es-x/no-iterator-prototype-drop": "error",
+        "es-x/no-iterator-prototype-every": "error",
+        "es-x/no-iterator-prototype-filter": "error",
+        "es-x/no-iterator-prototype-find": "error",
+        "es-x/no-iterator-prototype-flatmap": "error",
+        "es-x/no-iterator-prototype-foreach": "error",
+        "es-x/no-iterator-prototype-map": "error",
+        "es-x/no-iterator-prototype-reduce": "error",
+        "es-x/no-iterator-prototype-some": "error",
+        "es-x/no-iterator-prototype-take": "error",
+        "es-x/no-iterator-prototype-toarray": "error",
+        "es-x/no-iterator": "error",
+    },
+}
diff --git a/lib/configs/flat/no-new-in-esnext.js b/lib/configs/flat/no-new-in-esnext.js
index f100a61..1defda7 100644
--- a/lib/configs/flat/no-new-in-esnext.js
+++ b/lib/configs/flat/no-new-in-esnext.js
@@ -13,7 +13,20 @@ module.exports = {
     rules: {
         "es-x/no-dynamic-import-options": "error",
         "es-x/no-import-attributes": "error",
+        "es-x/no-iterator-prototype-drop": "error",
+        "es-x/no-iterator-prototype-every": "error",
+        "es-x/no-iterator-prototype-filter": "error",
+        "es-x/no-iterator-prototype-find": "error",
+        "es-x/no-iterator-prototype-flatmap": "error",
+        "es-x/no-iterator-prototype-foreach": "error",
+        "es-x/no-iterator-prototype-map": "error",
+        "es-x/no-iterator-prototype-reduce": "error",
+        "es-x/no-iterator-prototype-some": "error",
+        "es-x/no-iterator-prototype-take": "error",
+        "es-x/no-iterator-prototype-toarray": "error",
+        "es-x/no-iterator": "error",
         "es-x/no-json-modules": "error",
+        "es-x/no-promise-try": "error",
         "es-x/no-regexp-duplicate-named-capturing-groups": "error",
         "es-x/no-regexp-modifiers": "error",
         "es-x/no-set-prototype-difference": "error",
diff --git a/lib/configs/no-iterator-helpers.js b/lib/configs/no-iterator-helpers.js
new file mode 100644
index 0000000..8a3aab3
--- /dev/null
+++ b/lib/configs/no-iterator-helpers.js
@@ -0,0 +1,23 @@
+/**
+ * DON'T EDIT THIS FILE.
+ * This file was generated by "scripts/update-lib-configs.js" script.
+ */
+"use strict"
+
+module.exports = {
+    plugins: ["es-x"],
+    rules: {
+        "es-x/no-iterator-prototype-drop": "error",
+        "es-x/no-iterator-prototype-every": "error",
+        "es-x/no-iterator-prototype-filter": "error",
+        "es-x/no-iterator-prototype-find": "error",
+        "es-x/no-iterator-prototype-flatmap": "error",
+        "es-x/no-iterator-prototype-foreach": "error",
+        "es-x/no-iterator-prototype-map": "error",
+        "es-x/no-iterator-prototype-reduce": "error",
+        "es-x/no-iterator-prototype-some": "error",
+        "es-x/no-iterator-prototype-take": "error",
+        "es-x/no-iterator-prototype-toarray": "error",
+        "es-x/no-iterator": "error",
+    },
+}
diff --git a/lib/configs/no-new-in-esnext.js b/lib/configs/no-new-in-esnext.js
index d6eed7b..069a1c5 100644
--- a/lib/configs/no-new-in-esnext.js
+++ b/lib/configs/no-new-in-esnext.js
@@ -9,7 +9,20 @@ module.exports = {
     rules: {
         "es-x/no-dynamic-import-options": "error",
         "es-x/no-import-attributes": "error",
+        "es-x/no-iterator-prototype-drop": "error",
+        "es-x/no-iterator-prototype-every": "error",
+        "es-x/no-iterator-prototype-filter": "error",
+        "es-x/no-iterator-prototype-find": "error",
+        "es-x/no-iterator-prototype-flatmap": "error",
+        "es-x/no-iterator-prototype-foreach": "error",
+        "es-x/no-iterator-prototype-map": "error",
+        "es-x/no-iterator-prototype-reduce": "error",
+        "es-x/no-iterator-prototype-some": "error",
+        "es-x/no-iterator-prototype-take": "error",
+        "es-x/no-iterator-prototype-toarray": "error",
+        "es-x/no-iterator": "error",
         "es-x/no-json-modules": "error",
+        "es-x/no-promise-try": "error",
         "es-x/no-regexp-duplicate-named-capturing-groups": "error",
         "es-x/no-regexp-modifiers": "error",
         "es-x/no-set-prototype-difference": "error",
diff --git a/lib/index.js b/lib/index.js
index 9874280..9999941 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -16,6 +16,7 @@ module.exports = {
         "flat/no-import-attributes": require("./configs/flat/no-import-attributes"),
         "flat/no-intl-numberformat-v3": require("./configs/flat/no-intl-numberformat-v3"),
         "flat/no-is-usv-string": require("./configs/flat/no-is-usv-string"),
+        "flat/no-iterator-helpers": require("./configs/flat/no-iterator-helpers"),
         "flat/no-new-in-es5": require("./configs/flat/no-new-in-es5"),
         "flat/no-new-in-es2015": require("./configs/flat/no-new-in-es2015"),
         "flat/no-new-in-es2015-intl-api": require("./configs/flat/no-new-in-es2015-intl-api"),
@@ -68,6 +69,7 @@ module.exports = {
         "no-import-attributes": require("./configs/no-import-attributes"),
         "no-intl-numberformat-v3": require("./configs/no-intl-numberformat-v3"),
         "no-is-usv-string": require("./configs/no-is-usv-string"),
+        "no-iterator-helpers": require("./configs/no-iterator-helpers"),
         "no-new-in-es5": require("./configs/no-new-in-es5"),
         "no-new-in-es2015": require("./configs/no-new-in-es2015"),
         "no-new-in-es2015-intl-api": require("./configs/no-new-in-es2015-intl-api"),
@@ -222,6 +224,18 @@ module.exports = {
         "no-intl-relativetimeformat": require("./rules/no-intl-relativetimeformat"),
         "no-intl-segmenter": require("./rules/no-intl-segmenter"),
         "no-intl-supportedvaluesof": require("./rules/no-intl-supportedvaluesof"),
+        "no-iterator": require("./rules/no-iterator"),
+        "no-iterator-prototype-drop": require("./rules/no-iterator-prototype-drop"),
+        "no-iterator-prototype-every": require("./rules/no-iterator-prototype-every"),
+        "no-iterator-prototype-filter": require("./rules/no-iterator-prototype-filter"),
+        "no-iterator-prototype-find": require("./rules/no-iterator-prototype-find"),
+        "no-iterator-prototype-flatmap": require("./rules/no-iterator-prototype-flatmap"),
+        "no-iterator-prototype-foreach": require("./rules/no-iterator-prototype-foreach"),
+        "no-iterator-prototype-map": require("./rules/no-iterator-prototype-map"),
+        "no-iterator-prototype-reduce": require("./rules/no-iterator-prototype-reduce"),
+        "no-iterator-prototype-some": require("./rules/no-iterator-prototype-some"),
+        "no-iterator-prototype-take": require("./rules/no-iterator-prototype-take"),
+        "no-iterator-prototype-toarray": require("./rules/no-iterator-prototype-toarray"),
         "no-json": require("./rules/no-json"),
         "no-json-modules": require("./rules/no-json-modules"),
         "no-json-superset": require("./rules/no-json-superset"),
@@ -295,6 +309,7 @@ module.exports = {
         "no-promise-all-settled": require("./rules/no-promise-all-settled"),
         "no-promise-any": require("./rules/no-promise-any"),
         "no-promise-prototype-finally": require("./rules/no-promise-prototype-finally"),
+        "no-promise-try": require("./rules/no-promise-try"),
         "no-promise-withresolvers": require("./rules/no-promise-withresolvers"),
         "no-property-shorthands": require("./rules/no-property-shorthands"),
         "no-proxy": require("./rules/no-proxy"),
diff --git a/lib/rules/no-dynamic-import-options.js b/lib/rules/no-dynamic-import-options.js
index d6f0fd0..a7df92c 100644
--- a/lib/rules/no-dynamic-import-options.js
+++ b/lib/rules/no-dynamic-import-options.js
@@ -3,7 +3,7 @@
 module.exports = {
     meta: {
         docs: {
-            description: "disallow second parameter to `import()`",
+            description: "disallow the second parameter to `import()`",
             category: "ES2025",
             proposal: "import-attributes",
             recommended: false,
diff --git a/lib/rules/no-iterator-prototype-drop.js b/lib/rules/no-iterator-prototype-drop.js
new file mode 100644
index 0000000..077b7cd
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-drop.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.drop` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-drop.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["drop"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator-prototype-every.js b/lib/rules/no-iterator-prototype-every.js
new file mode 100644
index 0000000..f9476fc
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-every.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.every` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-every.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["every"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator-prototype-filter.js b/lib/rules/no-iterator-prototype-filter.js
new file mode 100644
index 0000000..6a990a3
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-filter.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.filter` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-filter.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["filter"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator-prototype-find.js b/lib/rules/no-iterator-prototype-find.js
new file mode 100644
index 0000000..8f21aaa
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-find.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.find` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-find.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["find"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator-prototype-flatmap.js b/lib/rules/no-iterator-prototype-flatmap.js
new file mode 100644
index 0000000..0d7bc66
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-flatmap.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.flatMap` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-flatmap.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["flatMap"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator-prototype-foreach.js b/lib/rules/no-iterator-prototype-foreach.js
new file mode 100644
index 0000000..aa0757b
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-foreach.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.forEach` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-foreach.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["forEach"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator-prototype-map.js b/lib/rules/no-iterator-prototype-map.js
new file mode 100644
index 0000000..1e318d4
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-map.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.map` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-map.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["map"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator-prototype-reduce.js b/lib/rules/no-iterator-prototype-reduce.js
new file mode 100644
index 0000000..3f3fe42
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-reduce.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.reduce` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-reduce.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["reduce"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator-prototype-some.js b/lib/rules/no-iterator-prototype-some.js
new file mode 100644
index 0000000..f7ed64b
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-some.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.some` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-some.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["some"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator-prototype-take.js b/lib/rules/no-iterator-prototype-take.js
new file mode 100644
index 0000000..c8aaf98
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-take.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.take` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-take.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["take"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator-prototype-toarray.js b/lib/rules/no-iterator-prototype-toarray.js
new file mode 100644
index 0000000..5a39ee1
--- /dev/null
+++ b/lib/rules/no-iterator-prototype-toarray.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator.prototype.toArray` method.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator-prototype-toarray.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Iterator: ["toArray"],
+        })
+    },
+}
diff --git a/lib/rules/no-iterator.js b/lib/rules/no-iterator.js
new file mode 100644
index 0000000..4b114ef
--- /dev/null
+++ b/lib/rules/no-iterator.js
@@ -0,0 +1,41 @@
+"use strict"
+
+const { READ, ReferenceTracker } = require("@eslint-community/eslint-utils")
+const { getSourceCode } = require("eslint-compat-utils")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Iterator` class.",
+            category: "ES2025",
+            proposal: "iterator-helpers",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-iterator.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' class is forbidden.",
+        },
+        schema: [],
+        type: "problem",
+    },
+    create(context) {
+        return {
+            "Program:exit"(program) {
+                const sourceCode = getSourceCode(context)
+                const tracker = new ReferenceTracker(
+                    sourceCode.getScope(program),
+                )
+                for (const { node, path } of tracker.iterateGlobalReferences({
+                    Iterator: { [READ]: true },
+                })) {
+                    context.report({
+                        node,
+                        messageId: "forbidden",
+                        data: { name: path.join(".") },
+                    })
+                }
+            },
+        }
+    },
+}
diff --git a/lib/rules/no-promise-try.js b/lib/rules/no-promise-try.js
new file mode 100644
index 0000000..890db3f
--- /dev/null
+++ b/lib/rules/no-promise-try.js
@@ -0,0 +1,46 @@
+/**
+ * @author Yosuke Ota
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const { READ, ReferenceTracker } = require("@eslint-community/eslint-utils")
+const { getSourceCode } = require("eslint-compat-utils")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow `Promise.try` function",
+            category: "ES2025",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-promise-try.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2025 '{{name}}' is forbidden.",
+        },
+        schema: [],
+        type: "problem",
+    },
+    create(context) {
+        return {
+            "Program:exit"(program) {
+                const sourceCode = getSourceCode(context)
+                const tracker = new ReferenceTracker(
+                    sourceCode.getScope(program),
+                )
+                for (const { node, path } of tracker.iterateGlobalReferences({
+                    Promise: {
+                        try: { [READ]: true },
+                    },
+                })) {
+                    context.report({
+                        node,
+                        messageId: "forbidden",
+                        data: { name: path.join(".") },
+                    })
+                }
+            },
+        }
+    },
+}
diff --git a/lib/util/define-prototype-method-handler/es-types.js b/lib/util/define-prototype-method-handler/es-types.js
new file mode 100644
index 0000000..4618812
--- /dev/null
+++ b/lib/util/define-prototype-method-handler/es-types.js
@@ -0,0 +1,684 @@
+// @ts-check
+
+"use strict"
+
+/**
+ * @typedef {import('./types').TypeName} TypeName
+ * @typedef {import('./types').TypeInfo} TypeInfo
+ * @typedef {import('./types').WellKnownGlobals} WellKnownGlobals
+ * @typedef {import('./types').WellKnownPrototypes} WellKnownPrototypes
+ */
+
+/** @type {TypeInfo} */
+const RETURN_STRING = {
+    type: "Function",
+    return: { type: "String" },
+}
+/** @type {TypeInfo} */
+const RETURN_NUMBER = {
+    type: "Function",
+    return: { type: "Number" },
+}
+/** @type {TypeInfo} */
+const RETURN_BOOLEAN = {
+    type: "Function",
+    return: { type: "Boolean" },
+}
+
+/** @type {WellKnownGlobals} */
+const WELLKNOWN_GLOBALS = {
+    String: {
+        ...RETURN_STRING,
+        /** @type {Record<import('./types').StringProperty,TypeInfo|undefined>} */
+        properties: {
+            fromCharCode: RETURN_STRING,
+            fromCodePoint: RETURN_STRING,
+            raw: RETURN_STRING,
+        },
+    },
+    Number: {
+        ...RETURN_NUMBER,
+        /** @type {Record<import('./types').NumberProperty,TypeInfo|undefined>} */
+        properties: {
+            EPSILON: { type: "Number" },
+            MAX_SAFE_INTEGER: { type: "Number" },
+            MAX_VALUE: { type: "Number" },
+            MIN_SAFE_INTEGER: { type: "Number" },
+            MIN_VALUE: { type: "Number" },
+            NaN: { type: "Number" },
+            NEGATIVE_INFINITY: { type: "Number" },
+            POSITIVE_INFINITY: { type: "Number" },
+            isFinite: RETURN_BOOLEAN,
+            isInteger: RETURN_BOOLEAN,
+            isNaN: RETURN_BOOLEAN,
+            isSafeInteger: RETURN_BOOLEAN,
+            parseFloat: RETURN_NUMBER,
+            parseInt: RETURN_NUMBER,
+        },
+    },
+    Boolean: {
+        ...RETURN_BOOLEAN,
+        /** @type {Record<import('./types').BooleanProperty,TypeInfo|undefined>} */
+        properties: {},
+    },
+    Symbol: {
+        type: "Function",
+        return: { type: "Symbol" },
+        /** @type {Record<import('./types').SymbolProperty,TypeInfo|undefined>} */
+        properties: {
+            for: { type: "Function", return: { type: "Symbol" } },
+            keyFor: RETURN_STRING,
+            asyncIterator: { type: "Symbol" },
+            hasInstance: { type: "Symbol" },
+            isConcatSpreadable: { type: "Symbol" },
+            iterator: { type: "Symbol" },
+            match: { type: "Symbol" },
+            matchAll: { type: "Symbol" },
+            replace: { type: "Symbol" },
+            search: { type: "Symbol" },
+            species: { type: "Symbol" },
+            split: { type: "Symbol" },
+            toPrimitive: { type: "Symbol" },
+            toStringTag: { type: "Symbol" },
+            unscopables: { type: "Symbol" },
+            dispose: { type: "Symbol" },
+            asyncDispose: { type: "Symbol" },
+            metadata: { type: "Symbol" },
+        },
+    },
+    BigInt: {
+        type: "Function",
+        return: { type: "BigInt" },
+        /** @type {Record<import('./types').BigIntProperty,TypeInfo|undefined>} */
+        properties: {
+            asIntN: { type: "Function", return: { type: "BigInt" } },
+            asUintN: { type: "Function", return: { type: "BigInt" } },
+        },
+    },
+    Object: {
+        type: "Function",
+        return: { type: "Object" },
+        /** @type {Record<import('./types').ObjectProperty,TypeInfo|undefined>} */
+        properties: {
+            assign: { type: "Function", return: { type: "Object" } },
+            create: { type: "Function", return: { type: "Object" } },
+            defineProperties: { type: "Function", return: { type: "Object" } },
+            defineProperty: { type: "Function", return: { type: "Object" } },
+            entries: { type: "Function", return: { type: "Array" } },
+            freeze: { type: "Function", return: { type: "Object" } },
+            fromEntries: { type: "Function", return: { type: "Object" } },
+            getOwnPropertyDescriptor: {
+                type: "Function",
+                return: { type: "Object" },
+            },
+            getOwnPropertyDescriptors: {
+                type: "Function",
+                return: { type: "Object" },
+            },
+            getOwnPropertyNames: {
+                type: "Function",
+                return: { type: "Array" },
+            },
+            getOwnPropertySymbols: {
+                type: "Function",
+                return: { type: "Array" },
+            },
+            getPrototypeOf: { type: "Function", return: { type: "Object" } },
+            groupBy: { type: "Function", return: { type: "Object" } },
+            hasOwn: RETURN_BOOLEAN,
+            is: RETURN_BOOLEAN,
+            isExtensible: RETURN_BOOLEAN,
+            isFrozen: RETURN_BOOLEAN,
+            isSealed: RETURN_BOOLEAN,
+            keys: { type: "Function", return: { type: "Array" } },
+            preventExtensions: { type: "Function", return: { type: "Object" } },
+            seal: { type: "Function", return: { type: "Object" } },
+            setPrototypeOf: { type: "Function", return: { type: "Object" } },
+            values: { type: "Function", return: { type: "Array" } },
+            prototype: { type: "Object" },
+        },
+    },
+    Function: {
+        type: "Function",
+        return: { type: "Function" },
+        /** @type {Record<import('./types').FunctionProperty,TypeInfo|undefined>} */
+        properties: {},
+    },
+    Array: {
+        type: "Function",
+        return: { type: "Array" },
+        /** @type {Record<import('./types').ArrayProperty,TypeInfo|undefined>} */
+        properties: {
+            from: { type: "Function", return: { type: "Array" } },
+            fromAsync: { type: "Function", return: { type: "Promise" } },
+            isArray: RETURN_BOOLEAN,
+            of: { type: "Function", return: { type: "Array" } },
+        },
+    },
+    RegExp: {
+        type: "Function",
+        return: { type: "RegExp" },
+        /** @type {Record<import('./types').RegExpProperty,TypeInfo|undefined>} */
+        properties: {
+            "$&": { type: "String" },
+            "$'": { type: "String" },
+            "$`": { type: "String" },
+            "$+": { type: "String" },
+            $_: { type: "String" },
+            $1: { type: "String" },
+            $2: { type: "String" },
+            $3: { type: "String" },
+            $4: { type: "String" },
+            $5: { type: "String" },
+            $6: { type: "String" },
+            $7: { type: "String" },
+            $8: { type: "String" },
+            $9: { type: "String" },
+            input: { type: "String" },
+            lastMatch: { type: "String" },
+            lastParen: { type: "String" },
+            leftContext: { type: "String" },
+            rightContext: { type: "String" },
+        },
+    },
+    Date: {
+        type: "Function",
+        return: { type: "Date" },
+        /** @type {Record<import('./types').DateProperty,TypeInfo|undefined>} */
+        properties: {
+            now: { type: "Function", return: { type: "Number" } },
+            parse: { type: "Function", return: { type: "Number" } },
+            UTC: { type: "Function", return: { type: "Number" } },
+        },
+    },
+    Promise: {
+        type: "Function",
+        return: { type: "Promise" },
+        /** @type {Record<import('./types').PromiseProperty,TypeInfo|undefined>} */
+        properties: {
+            all: { type: "Function", return: { type: "Promise" } },
+            allSettled: { type: "Function", return: { type: "Promise" } },
+            any: { type: "Function", return: { type: "Promise" } },
+            race: { type: "Function", return: { type: "Promise" } },
+            reject: { type: "Function", return: { type: "Promise" } },
+            resolve: { type: "Function", return: { type: "Promise" } },
+            try: { type: "Function", return: { type: "Promise" } },
+            withResolvers: {
+                type: "Function",
+                return: {
+                    type: "Object",
+                    properties: {
+                        promise: { type: "Promise" },
+                        resolve: { type: "Function" },
+                        reject: { type: "Function" },
+                    },
+                },
+            },
+        },
+    },
+    Int8Array: buildGlobalTypedArrayTypeInfo("Int8Array"),
+    Uint8Array: buildGlobalTypedArrayTypeInfo("Uint8Array"),
+    Uint8ClampedArray: buildGlobalTypedArrayTypeInfo("Uint8ClampedArray"),
+    Int16Array: buildGlobalTypedArrayTypeInfo("Int16Array"),
+    Uint16Array: buildGlobalTypedArrayTypeInfo("Uint16Array"),
+    Int32Array: buildGlobalTypedArrayTypeInfo("Int32Array"),
+    Uint32Array: buildGlobalTypedArrayTypeInfo("Uint32Array"),
+    Float32Array: buildGlobalTypedArrayTypeInfo("Float32Array"),
+    Float64Array: buildGlobalTypedArrayTypeInfo("Float64Array"),
+    BigInt64Array: buildGlobalTypedArrayTypeInfo("BigInt64Array"),
+    BigUint64Array: buildGlobalTypedArrayTypeInfo("BigUint64Array"),
+    ArrayBuffer: {
+        type: "Function",
+        return: { type: "ArrayBuffer" },
+        /** @type {Record<import('./types').ArrayBufferProperty,TypeInfo|undefined>} */
+        properties: {
+            isView: RETURN_BOOLEAN,
+        },
+    },
+    SharedArrayBuffer: {
+        type: "Function",
+        return: { type: "SharedArrayBuffer" },
+        /** @type {Record<import('./types').SharedArrayBufferProperty,TypeInfo|undefined>} */
+        properties: {},
+    },
+    Intl: {
+        type: "Object",
+        /** @type {Record<import('./types').IntlProperty,TypeInfo|undefined>} */
+        properties: {
+            Collator: {
+                type: "Function",
+                return: { type: "Intl.Collator" },
+            },
+            DateTimeFormat: {
+                type: "Function",
+                return: { type: "Intl.DateTimeFormat" },
+            },
+            ListFormat: {
+                type: "Function",
+                return: { type: "Intl.ListFormat" },
+            },
+            NumberFormat: {
+                type: "Function",
+                return: { type: "Intl.NumberFormat" },
+            },
+            PluralRules: {
+                type: "Function",
+                return: { type: "Intl.PluralRules" },
+            },
+            RelativeTimeFormat: {
+                type: "Function",
+                return: { type: "Intl.RelativeTimeFormat" },
+            },
+            Segmenter: {
+                type: "Function",
+                return: { type: "Intl.Segmenter" },
+            },
+            DisplayNames: {
+                type: "Function",
+                return: { type: "Intl.DisplayNames" },
+            },
+            Locale: {
+                type: "Function",
+                return: { type: "Intl.Locale" },
+            },
+            getCanonicalLocales: {
+                type: "Function",
+                return: { type: "Array" },
+            },
+            supportedValuesOf: {
+                type: "Function",
+                return: { type: "Array" },
+            },
+        },
+    },
+    Iterator: {
+        type: "Function",
+        return: { type: "Iterator" },
+        /** @type {Record<import('./types').IteratorProperty,TypeInfo|undefined>} */
+        properties: {
+            from: { type: "Function", return: { type: "Iterator" } },
+        },
+    },
+    undefined: { type: "undefined" },
+    NaN: { type: "Number" },
+    Infinity: { type: "Number" },
+}
+
+/** @type {Record<import('./types').ObjectPrototypeProperty, TypeInfo>} */
+const OBJECT_PROTOTYPE = {
+    constructor: { type: "Function" },
+    toString: RETURN_STRING,
+    toLocaleString: RETURN_STRING,
+    valueOf: { type: "Function" },
+    hasOwnProperty: RETURN_BOOLEAN,
+    isPrototypeOf: RETURN_BOOLEAN,
+    propertyIsEnumerable: RETURN_BOOLEAN,
+}
+/** @type {Record<import('./types').ArrayPrototypeProperty, TypeInfo>} */
+const ARRAY_PROPERTIES = {
+    at: { type: "Function" },
+    concat: { type: "Function", return: { type: "Array" } },
+    copyWithin: { type: "Function", return: { type: "Array" } },
+    entries: { type: "Function", return: { type: "Iterator" } },
+    every: RETURN_BOOLEAN,
+    fill: { type: "Function", return: { type: "Array" } },
+    filter: { type: "Function", return: { type: "Array" } },
+    find: { type: "Function" },
+    findIndex: RETURN_NUMBER,
+    findLast: { type: "Function" },
+    findLastIndex: RETURN_NUMBER,
+    flat: { type: "Function", return: { type: "Array" } },
+    flatMap: { type: "Function", return: { type: "Array" } },
+    forEach: { type: "Function" },
+    includes: RETURN_BOOLEAN,
+    indexOf: RETURN_NUMBER,
+    join: RETURN_STRING,
+    keys: { type: "Function", return: { type: "Iterator" } },
+    lastIndexOf: RETURN_NUMBER,
+    map: { type: "Function", return: { type: "Array" } },
+    pop: { type: "Function" },
+    push: { type: "Function" },
+    reduce: { type: "Function" },
+    reduceRight: { type: "Function" },
+    reverse: { type: "Function", return: { type: "Array" } },
+    shift: { type: "Function" },
+    slice: { type: "Function", return: { type: "Array" } },
+    some: RETURN_BOOLEAN,
+    sort: { type: "Function", return: { type: "Array" } },
+    splice: { type: "Function", return: { type: "Array" } },
+    toReversed: { type: "Function", return: { type: "Array" } },
+    toSorted: { type: "Function", return: { type: "Array" } },
+    toSpliced: { type: "Function", return: { type: "Array" } },
+    unshift: { type: "Function" },
+    values: { type: "Function", return: { type: "Iterator" } },
+    with: { type: "Function", return: { type: "Array" } },
+    // Properties
+    length: { type: "Number" },
+}
+/** @type {Record<import('./types').RegExpArrayPrototypeProperty, TypeInfo>} */
+const REGEXP_ARRAY_PROPERTIES = new Proxy(
+    {
+        ...ARRAY_PROPERTIES,
+        index: { type: "Number" },
+        input: { type: "String" },
+        groups: { type: "Object" },
+        indices: { type: "Array" },
+        at: { type: "Function", return: { type: "String" } },
+    },
+    {
+        get(target, propertyName) {
+            if (isFinite(Number(propertyName))) {
+                return { type: "String" }
+            }
+            const key =
+                /** @type {Exclude<import('./types').RegExpArrayPrototypeProperty, number>} */ (
+                    propertyName
+                )
+            return target[key]
+        },
+    },
+)
+const WELLKNOWN_PROTOTYPE = /** @type {WellKnownPrototypes} */ ({
+    /** @type {Record<import('./types').StringPrototypeProperty, TypeInfo>} */
+    String: {
+        // HTML
+        anchor: RETURN_STRING,
+        big: RETURN_STRING,
+        blink: RETURN_STRING,
+        bold: RETURN_STRING,
+        fixed: RETURN_STRING,
+        fontcolor: RETURN_STRING,
+        fontsize: RETURN_STRING,
+        italics: RETURN_STRING,
+        link: RETURN_STRING,
+        small: RETURN_STRING,
+        strike: RETURN_STRING,
+        sub: RETURN_STRING,
+        sup: RETURN_STRING,
+        // ES
+        charAt: RETURN_STRING,
+        at: RETURN_STRING,
+        charCodeAt: RETURN_NUMBER,
+        codePointAt: RETURN_NUMBER,
+        concat: RETURN_STRING,
+        endsWith: RETURN_BOOLEAN,
+        includes: RETURN_BOOLEAN,
+        indexOf: RETURN_NUMBER,
+        lastIndexOf: RETURN_NUMBER,
+        localeCompare: RETURN_NUMBER,
+        match: { type: "Function", return: { type: "Array" } },
+        matchAll: { type: "Function", return: { type: "Iterator" } },
+        normalize: RETURN_STRING,
+        padEnd: RETURN_STRING,
+        padStart: RETURN_STRING,
+        repeat: RETURN_STRING,
+        replace: RETURN_STRING,
+        replaceAll: RETURN_STRING,
+        search: RETURN_NUMBER,
+        slice: RETURN_STRING,
+        split: { type: "Function", return: { type: "Array" } },
+        startsWith: RETURN_BOOLEAN,
+        substr: RETURN_STRING,
+        substring: RETURN_STRING,
+        toLowerCase: RETURN_STRING,
+        toLocaleLowerCase: RETURN_STRING,
+        toUpperCase: RETURN_STRING,
+        toLocaleUpperCase: RETURN_STRING,
+        trim: RETURN_STRING,
+        trimEnd: RETURN_STRING,
+        trimLeft: RETURN_STRING,
+        trimRight: RETURN_STRING,
+        trimStart: RETURN_STRING,
+        valueOf: RETURN_STRING,
+        isWellFormed: RETURN_BOOLEAN,
+        toWellFormed: RETURN_STRING,
+        // Properties
+        length: { type: "Number" },
+    },
+    /** @type {Record<import('./types').NumberPrototypeProperty, TypeInfo>} */
+    Number: {
+        toExponential: RETURN_STRING,
+        toFixed: RETURN_STRING,
+        toPrecision: RETURN_STRING,
+        valueOf: RETURN_NUMBER,
+    },
+    /** @type {Record<import('./types').BooleanPrototypeProperty, TypeInfo>} */
+    Boolean: {
+        valueOf: { type: "Boolean" },
+    },
+    /** @type {Record<import('./types').SymbolPrototypeProperty, TypeInfo>} */
+    Symbol: {
+        description: { type: "String" },
+        valueOf: { type: "Symbol" },
+    },
+    /** @type {Record<import('./types').BigIntPrototypeProperty, TypeInfo>} */
+    BigInt: {
+        valueOf: { type: "BigInt" },
+    },
+    /** @type {Record<import('./types').FunctionPrototypeProperty, TypeInfo>} */
+    Function: {
+        apply: { type: "Function" },
+        bind: { type: "Function", return: { type: "Function" } },
+        call: { type: "Function" },
+        arguments: { type: "Object" },
+        caller: { type: "Function" },
+        length: { type: "Number" },
+        name: { type: "String" },
+        prototype: { type: "Object" },
+    },
+    /** @type {Record<import('./types').ArrayPrototypeProperty, TypeInfo>} */
+    Array: ARRAY_PROPERTIES,
+    /** @type {Record<import('./types').RegExpPrototypeProperty, TypeInfo>} */
+    RegExp: {
+        compile: { type: "Function" },
+        test: RETURN_BOOLEAN,
+        exec: {
+            type: "Function",
+            return: { type: "Array", properties: REGEXP_ARRAY_PROPERTIES },
+        },
+        // Properties
+        dotAll: { type: "Boolean" },
+        flags: { type: "String" },
+        global: { type: "Boolean" },
+        hasIndices: { type: "Boolean" },
+        ignoreCase: { type: "Boolean" },
+        lastIndex: { type: "Number" },
+        multiline: { type: "Boolean" },
+        source: { type: "String" },
+        sticky: { type: "Boolean" },
+        unicode: { type: "Boolean" },
+        unicodeSets: { type: "Boolean" },
+    },
+    /** @type {Record<import('./types').DatePrototypeProperty, TypeInfo>} */
+    Date: {
+        getDate: RETURN_NUMBER,
+        getDay: RETURN_NUMBER,
+        getFullYear: RETURN_NUMBER,
+        getHours: RETURN_NUMBER,
+        getMilliseconds: RETURN_NUMBER,
+        getMinutes: RETURN_NUMBER,
+        getMonth: RETURN_NUMBER,
+        getSeconds: RETURN_NUMBER,
+        getTime: RETURN_NUMBER,
+        getTimezoneOffset: RETURN_NUMBER,
+        getUTCDate: RETURN_NUMBER,
+        getUTCDay: RETURN_NUMBER,
+        getUTCFullYear: RETURN_NUMBER,
+        getUTCHours: RETURN_NUMBER,
+        getUTCMilliseconds: RETURN_NUMBER,
+        getUTCMinutes: RETURN_NUMBER,
+        getUTCMonth: RETURN_NUMBER,
+        getUTCSeconds: RETURN_NUMBER,
+        getYear: RETURN_NUMBER,
+        setDate: RETURN_NUMBER,
+        setFullYear: RETURN_NUMBER,
+        setHours: RETURN_NUMBER,
+        setMilliseconds: RETURN_NUMBER,
+        setMinutes: RETURN_NUMBER,
+        setMonth: RETURN_NUMBER,
+        setSeconds: RETURN_NUMBER,
+        setTime: RETURN_NUMBER,
+        setUTCDate: RETURN_NUMBER,
+        setUTCFullYear: RETURN_NUMBER,
+        setUTCHours: RETURN_NUMBER,
+        setUTCMilliseconds: RETURN_NUMBER,
+        setUTCMinutes: RETURN_NUMBER,
+        setUTCMonth: RETURN_NUMBER,
+        setUTCSeconds: RETURN_NUMBER,
+        setYear: RETURN_NUMBER,
+        toDateString: RETURN_STRING,
+        toISOString: RETURN_STRING,
+        toJSON: RETURN_STRING,
+        toGMTString: RETURN_STRING,
+        toLocaleDateString: RETURN_STRING,
+        toLocaleTimeString: RETURN_STRING,
+        toTimeString: RETURN_STRING,
+        toUTCString: RETURN_STRING,
+        valueOf: RETURN_NUMBER,
+    },
+    /** @type {Record<import('./types').PromisePrototypeProperty, TypeInfo>} */
+    Promise: {
+        catch: { type: "Function", return: { type: "Promise" } },
+        finally: { type: "Function", return: { type: "Promise" } },
+        then: { type: "Function", return: { type: "Promise" } },
+    },
+    Int8Array: buildTypedArrayPrototypeTypeInfo("Int8Array"),
+    Uint8Array: buildTypedArrayPrototypeTypeInfo("Uint8Array"),
+    Uint8ClampedArray: buildTypedArrayPrototypeTypeInfo("Uint8ClampedArray"),
+    Int16Array: buildTypedArrayPrototypeTypeInfo("Int16Array"),
+    Uint16Array: buildTypedArrayPrototypeTypeInfo("Uint16Array"),
+    Int32Array: buildTypedArrayPrototypeTypeInfo("Int32Array"),
+    Uint32Array: buildTypedArrayPrototypeTypeInfo("Uint32Array"),
+    Float32Array: buildTypedArrayPrototypeTypeInfo("Float32Array"),
+    Float64Array: buildTypedArrayPrototypeTypeInfo("Float64Array"),
+    BigInt64Array: buildTypedArrayPrototypeTypeInfo("BigInt64Array"),
+    BigUint64Array: buildTypedArrayPrototypeTypeInfo("BigUint64Array"),
+    /** @type {Record<import('./types').ArrayBufferPrototypeProperty, TypeInfo>} */
+    ArrayBuffer: {
+        resize: { type: "Function" },
+        slice: { type: "Function", return: { type: "ArrayBuffer" } },
+        transfer: { type: "Function", return: { type: "ArrayBuffer" } },
+        transferToFixedLength: {
+            type: "Function",
+            return: { type: "ArrayBuffer" },
+        },
+        // Properties
+        byteLength: { type: "Number" },
+        detached: { type: "Boolean" },
+        maxByteLength: { type: "Number" },
+        resizable: { type: "Boolean" },
+    },
+    /** @type {Record<import('./types').SharedArrayBufferPrototypeProperty, TypeInfo>} */
+    SharedArrayBuffer: {
+        grow: { type: "Function" },
+        slice: { type: "Function", return: { type: "SharedArrayBuffer" } },
+        // Properties
+        byteLength: { type: "Number" },
+        growable: { type: "Boolean" },
+        maxByteLength: { type: "Number" },
+    },
+    /** @type {Record<import('./types').IteratorPrototypeProperty, TypeInfo>} */
+    Iterator: {
+        next: { type: "Function" },
+        return: { type: "Function" },
+        throw: { type: "Function" },
+        // iterator-helpers
+        map: { type: "Function", return: { type: "Iterator" } },
+        filter: { type: "Function", return: { type: "Iterator" } },
+        take: { type: "Function", return: { type: "Iterator" } },
+        drop: { type: "Function", return: { type: "Iterator" } },
+        flatMap: { type: "Function", return: { type: "Iterator" } },
+        reduce: { type: "Function" },
+        toArray: { type: "Function", return: { type: "Array" } },
+        forEach: { type: "Function" },
+        some: RETURN_BOOLEAN,
+        every: RETURN_BOOLEAN,
+        find: { type: "Function" },
+    },
+})
+
+/**
+ * @param {TypeInfo} typeInfo
+ * @param {string} propertyName
+ * @returns {TypeInfo | null}
+ */
+function getPropertyType(typeInfo, propertyName) {
+    const prop = typeInfo.properties?.[propertyName]
+    if (prop) {
+        return prop
+    }
+    const proto = WELLKNOWN_PROTOTYPE[typeInfo.type]?.[propertyName]
+    if (proto) {
+        return proto
+    }
+    return (
+        OBJECT_PROTOTYPE[
+            /** @type {import('./types').ObjectPrototypeProperty} */ (
+                propertyName
+            )
+        ] ?? null
+    )
+}
+
+module.exports = { WELLKNOWN_GLOBALS, getPropertyType }
+
+/**
+ * @param {TypeName} type
+ * @returns {TypeInfo}
+ */
+function buildGlobalTypedArrayTypeInfo(type) {
+    return {
+        type: "Function",
+        return: { type },
+        /** @type {Record<import('./types').TypedArrayProperty,TypeInfo|undefined>} */
+        properties: {
+            BYTES_PER_ELEMENT: { type: "Number" },
+            from: { type: "Function", return: { type } },
+            of: { type: "Function", return: { type } },
+        },
+    }
+}
+
+/**
+ * @param {TypeName} type
+ * @returns {Record<import('./types').TypedArrayPrototypeProperty, TypeInfo>}
+ */
+function buildTypedArrayPrototypeTypeInfo(type) {
+    return {
+        at: { type: "Function" },
+        copyWithin: { type: "Function", return: { type } },
+        entries: { type: "Function", return: { type: "Iterator" } },
+        every: RETURN_BOOLEAN,
+        fill: { type: "Function", return: { type } },
+        filter: { type: "Function", return: { type } },
+        find: { type: "Function" },
+        findIndex: RETURN_NUMBER,
+        findLast: { type: "Function" },
+        findLastIndex: RETURN_NUMBER,
+        forEach: { type: "Function" },
+        includes: RETURN_BOOLEAN,
+        indexOf: RETURN_NUMBER,
+        join: RETURN_STRING,
+        keys: { type: "Function", return: { type: "Iterator" } },
+        lastIndexOf: RETURN_NUMBER,
+        map: { type: "Function", return: { type } },
+        reduce: { type: "Function" },
+        reduceRight: { type: "Function" },
+        reverse: { type: "Function", return: { type } },
+        slice: { type: "Function", return: { type } },
+        some: RETURN_BOOLEAN,
+        sort: { type: "Function", return: { type } },
+        toReversed: { type: "Function", return: { type } },
+        toSorted: { type: "Function", return: { type } },
+        values: { type: "Function", return: { type: "Iterator" } },
+        with: { type: "Function", return: { type } },
+        set: { type: "Function" },
+        subarray: { type: "Function", return: { type } },
+        valueOf: { type: "Function" },
+        // Properties
+        length: { type: "Number" },
+        buffer: { type: "ArrayBuffer" },
+        byteLength: { type: "Number" },
+        byteOffset: { type: "Number" },
+    }
+}
diff --git a/lib/util/define-prototype-method-handler/object-type-checker-for-ts.js b/lib/util/define-prototype-method-handler/object-type-checker-for-ts.js
index fb0c213..1760665 100644
--- a/lib/util/define-prototype-method-handler/object-type-checker-for-ts.js
+++ b/lib/util/define-prototype-method-handler/object-type-checker-for-ts.js
@@ -173,7 +173,10 @@ function buildObjectTypeCheckerForTS(context, aggressiveResult) {
                 // ReadonlyArray, ReadonlyMap, ReadonlySet
                 escapedName === `Readonly${className}` ||
                 // CallableFunction
-                (className === "Function" && escapedName === "CallableFunction")
+                (className === "Function" &&
+                    escapedName === "CallableFunction") ||
+                // IteratorObject
+                (className === "Iterator" && escapedName === "IteratorObject")
             )
         }
         return checker.getFullyQualifiedName(symbol) === className
diff --git a/lib/util/define-prototype-method-handler/object-type-checker.js b/lib/util/define-prototype-method-handler/object-type-checker.js
index 8d6d39e..a320033 100644
--- a/lib/util/define-prototype-method-handler/object-type-checker.js
+++ b/lib/util/define-prototype-method-handler/object-type-checker.js
@@ -1,7 +1,11 @@
 "use strict"
 
-const { findVariable } = require("@eslint-community/eslint-utils")
+const {
+    findVariable,
+    getPropertyName,
+} = require("@eslint-community/eslint-utils")
 const { getSourceCode } = require("eslint-compat-utils")
+const { WELLKNOWN_GLOBALS, getPropertyType } = require("./es-types")
 
 module.exports = { buildObjectTypeChecker, buildExpressionTypeProvider }
 
@@ -9,122 +13,15 @@ module.exports = { buildObjectTypeChecker, buildExpressionTypeProvider }
  * @typedef {import("eslint").Rule.RuleContext} RuleContext
  * @typedef {import("estree").MemberExpression} MemberExpression
  * @typedef {import("estree").Expression} Expression
+ * @typedef {import("estree").FunctionExpression} FunctionExpression
+ * @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression
+ * @typedef {import("estree").FunctionDeclaration} FunctionDeclaration
  */
 
 /**
- * @typedef {"Array"
- *         | "Date"
- *         | "Function"
- *         | "Intl.Collator"
- *         | "Intl.DateTimeFormat"
- *         | "Intl.ListFormat"
- *         | "Intl.NumberFormat"
- *         | "Intl.PluralRules"
- *         | "Intl.RelativeTimeFormat"
- *         | "Intl.Segmenter"
- *         | "Promise"
- *         | "RegExp"
- *         | "String"
- *         | "Symbol"
- *         | "Int8Array"
- *         | "Uint8Array"
- *         | "Uint8ClampedArray"
- *         | "Int16Array"
- *         | "Uint16Array"
- *         | "Int32Array"
- *         | "Uint32Array"
- *         | "Float32Array"
- *         | "Float64Array"
- *         | "BigInt64Array"
- *         | "BigUint64Array"
- *         | "Object"
- *         | "Number"
- *         | "Boolean"
- *         | "BigInt"
- *         | "null"
- *         | "undefined"
- *  } TypeName
+ * @typedef {import('./types').TypeInfo} TypeInfo
  */
 
-/**
- * @typedef {Record<
- *   string,
- *     WellKnownGlobalFunction
- *   | WellKnownGlobalObject
- *   | { type: "undefined" }
- *   | { type: "Number" }
- *   | undefined>
- * } WellKnownGlobals
- */
-/**
- * @typedef {object} WellKnownGlobalFunction
- * @property {"Function"} type
- * @property {TypeName} returnType
- */
-/**
- * @typedef {object} WellKnownGlobalObject
- * @property {"Object"} type
- * @property {WellKnownGlobals} properties
- */
-
-/** @type {WellKnownGlobals} */
-const WELLKNOWN_GLOBALS = {
-    String: { type: "Function", returnType: "String" },
-    Number: { type: "Function", returnType: "Number" },
-    Boolean: { type: "Function", returnType: "Boolean" },
-    Symbol: { type: "Function", returnType: "Symbol" },
-    BigInt: { type: "Function", returnType: "BigInt" },
-    Object: { type: "Function", returnType: "Object" },
-    Function: { type: "Function", returnType: "Function" },
-    Array: { type: "Function", returnType: "Array" },
-    RegExp: { type: "Function", returnType: "RegExp" },
-    Date: { type: "Function", returnType: "Date" },
-    Promise: { type: "Function", returnType: "Promise" },
-    Int8Array: { type: "Function", returnType: "Int8Array" },
-    Uint8Array: { type: "Function", returnType: "Uint8Array" },
-    Uint8ClampedArray: { type: "Function", returnType: "Uint8ClampedArray" },
-    Int16Array: { type: "Function", returnType: "Int16Array" },
-    Uint16Array: { type: "Function", returnType: "Uint16Array" },
-    Int32Array: { type: "Function", returnType: "Int32Array" },
-    Uint32Array: { type: "Function", returnType: "Uint32Array" },
-    Float32Array: { type: "Function", returnType: "Float32Array" },
-    Float64Array: { type: "Function", returnType: "Float64Array" },
-    BigInt64Array: { type: "Function", returnType: "BigInt64Array" },
-    BigUint64Array: { type: "Function", returnType: "BigUint64Array" },
-    ArrayBuffer: { type: "Function", returnType: "ArrayBuffer" },
-    SharedArrayBuffer: { type: "Function", returnType: "SharedArrayBuffer" },
-    Intl: {
-        type: "Object",
-        properties: {
-            Collator: { type: "Function", returnType: "Intl.Collator" },
-            DateTimeFormat: {
-                type: "Function",
-                returnType: "Intl.DateTimeFormat",
-            },
-            ListFormat: {
-                type: "Function",
-                returnType: "Intl.ListFormat",
-            },
-            NumberFormat: {
-                type: "Function",
-                returnType: "Intl.NumberFormat",
-            },
-            PluralRules: {
-                type: "Function",
-                returnType: "Intl.PluralRules",
-            },
-            RelativeTimeFormat: {
-                type: "Function",
-                returnType: "Intl.RelativeTimeFormat",
-            },
-            Segmenter: { type: "Function", returnType: "Intl.Segmenter" },
-        },
-    },
-    undefined: { type: "undefined" },
-    NaN: { type: "Number" },
-    Infinity: { type: "Number" },
-}
-
 /**
  * Build object type checker.
  * @param {RuleContext} context The rule context.
@@ -147,7 +44,7 @@ const cache = new WeakMap()
 /**
  * Build expression type provider.
  * @param {RuleContext} context The rule context.
- * @returns {((node: Expression) => TypeName | null)} Returns an expression type provider.
+ * @returns {((node: Expression) => TypeInfo | null)} Returns an expression type provider.
  */
 function buildExpressionTypeProvider(context) {
     const key = getSourceCode(context).ast
@@ -161,61 +58,74 @@ function buildExpressionTypeProvider(context) {
 /**
  * Build expression type provider.
  * @param {RuleContext} context The rule context.
- * @returns {((node: Expression) => TypeName | null)} Returns an expression type provider.
+ * @returns {((node: Expression) => TypeInfo | null)} Returns an expression type provider.
  */
 function buildExpressionTypeProviderImpl(context) {
-    /** @type {Record<Expression['type'], (node: Expression) => TypeName | null>} */
-    const GET_TYPES = {
-        ArrayExpression: () => "Array",
-        ObjectExpression: () => "Object",
-        ArrowFunctionExpression: () => "Function",
-        FunctionExpression: () => "Function",
-        Literal: getLiteralType,
-        TemplateLiteral: () => "String",
-        Identifier: getIdentifierType,
+    /** @type {Record<Expression['type']|'FunctionDeclaration', (node: Expression|FunctionDeclaration) => TypeInfo | null>} */
+    const GET_TYPE_INFOS = {
+        ArrayExpression: () => ({ type: "Array" }),
+        ObjectExpression: () => ({ type: "Object" }),
+        FunctionDeclaration: getFunctionTypeInfo,
+        ArrowFunctionExpression: getFunctionTypeInfo,
+        FunctionExpression: getFunctionTypeInfo,
+        Literal: getLiteralTypeInfo,
+        TemplateLiteral: () => ({ type: "String" }),
+        Identifier: getIdentifierTypeInfo,
+        MemberExpression: getMemberExpressionTypeInfo,
         /** @param {import("estree").BinaryExpression} node */
         BinaryExpression: (node) =>
-            getOperatorType(node.operator, node.left, node.right),
+            getOperatorTypeInfo(node.operator, node.left, node.right),
         /** @param {import("estree").LogicalExpression} node */
         LogicalExpression: (node) =>
-            getOperatorType(node.operator, node.left, node.right),
+            getOperatorTypeInfo(node.operator, node.left, node.right),
         /** @param {import("estree").AssignmentExpression} node */
         AssignmentExpression: (node) =>
-            getOperatorType(node.operator, node.left, node.right),
-        UnaryExpression: getUnaryExpressionType,
-        UpdateExpression: () => "Number",
-        ClassExpression: () => "Function",
-        ChainExpression: (node) => getType(node.expression),
+            getOperatorTypeInfo(node.operator, node.left, node.right),
+        UnaryExpression: getUnaryExpressionTypeInfo,
+        UpdateExpression: () => ({ type: "Number" }),
+        ClassExpression: () => ({ type: "Function" }),
+        ChainExpression: (node) => getTypeInfo(node.expression),
         /** @param {import("estree").SequenceExpression} node */
         SequenceExpression: (node) =>
-            getType(node.expressions[node.expressions.length - 1]),
-        CallExpression: getCallExpressionType,
-        NewExpression: getCallExpressionType,
-        TaggedTemplateExpression: getCallExpressionType,
+            getTypeInfo(node.expressions[node.expressions.length - 1]),
+        CallExpression: getCallExpressionTypeInfo,
+        NewExpression: getCallExpressionTypeInfo,
+        TaggedTemplateExpression: getCallExpressionTypeInfo,
         /** @param {import("estree").ConditionalExpression} node */
         ConditionalExpression(node) {
-            const consequent = getType(node.consequent)
-            const alternate = getType(node.alternate)
-            return consequent === alternate ? consequent : null
+            const consequent = getTypeInfo(node.consequent)
+            const alternate = getTypeInfo(node.alternate)
+            return {
+                get type() {
+                    return consequent?.type === alternate?.type
+                        ? (consequent?.type ?? null)
+                        : null
+                },
+                get return() {
+                    return consequent?.return?.type === alternate?.return?.type
+                        ? (consequent?.return?.type ?? null)
+                        : null
+                },
+            }
         },
     }
 
-    const tracked = new Map()
-    return getType
+    const trackedTypeInfo = new Map()
+    return (node) => getTypeInfo(node)?.type ?? null
 
     /**
-     * Gets the type name of the given node.
-     * @param {Expression} node The Expression node
-     * @returns {TypeName | null} The type name of expression.
+     * Gets the type info of the given node.
+     * @param {Expression|FunctionDeclaration} node The Expression node
+     * @returns {TypeInfo | null} The type info of expression.
      */
-    function getType(node) {
-        if (tracked.has(node)) {
-            return tracked.get(node)
+    function getTypeInfo(node) {
+        if (trackedTypeInfo.has(node)) {
+            return trackedTypeInfo.get(node)
         }
-        tracked.set(node, null)
+        trackedTypeInfo.set(node, null)
         try {
-            const result = GET_TYPES[node.type]?.(node) ?? null
-            tracked.set(node, result)
+            const result = GET_TYPE_INFOS[node.type]?.(node) ?? null
+            trackedTypeInfo.set(node, result)
             return result
         } catch {
             return null
@@ -235,62 +145,65 @@ function buildExpressionTypeProviderImpl(context) {
 
     /**
      * @param {import("estree").Literal} node
-     * @returns {TypeName | null}
+     * @returns {TypeInfo | null}
      */
-    function getLiteralType(node) {
+    function getLiteralTypeInfo(node) {
         if (node.regex) {
-            return "RegExp"
+            return { type: "RegExp" }
         }
         if (node.bigint) {
-            return "BigInt"
+            return { type: "BigInt" }
         }
         if (node.value == null) {
-            return "null"
+            return { type: "null" }
         }
         const valueType = typeof node.value
         if (valueType === "string") {
-            return "String"
+            return { type: "String" }
         }
         if (valueType === "number") {
-            return "Number"
+            return { type: "Number" }
         }
         if (valueType === "boolean") {
-            return "Boolean"
+            return { type: "Boolean" }
         }
-        return valueType[0].toUpperCase() + valueType.slice(1)
+        return { type: valueType[0].toUpperCase() + valueType.slice(1) }
     }
 
     /**
      * @param {import("estree").Identifier} node
-     * @returns {TypeName | null}
+     * @returns {TypeInfo | null}
      */
-    function getIdentifierType(node) {
+    function getIdentifierTypeInfo(node) {
         const variable = findVariableFromIdentifier(node)
-        if (variable) {
-            if (variable.defs.length === 0) {
-                // It is a global variable
-                return WELLKNOWN_GLOBALS[node.name]?.type ?? null
-            } else if (variable.defs.length === 1) {
-                const def = variable.defs[0]
-                if (def.type === "Variable") {
-                    if (
-                        // It has an initial value.
-                        def.node.init &&
-                        // It does not write new values.
-                        (def.parent.kind === "const" ||
-                            variable.references.every(
-                                (ref) =>
-                                    ref.isReadOnly() ||
-                                    ref.identifier === def.name,
-                            ))
-                    ) {
-                        // The type of the initial value is the type of the variable.
-                        return getType(def.node.init)
-                    }
-                } else if (def.type === "FunctionName") {
-                    return "Function"
-                }
+        if (!variable) {
+            return null
+        }
+        if (variable.defs.length === 0) {
+            // It is a global variable
+            return WELLKNOWN_GLOBALS[node.name]
+        }
+        if (variable.defs.length !== 1) {
+            return null
+        }
+        const def = variable.defs[0]
+        if (def.type === "Variable") {
+            if (
+                // It has an initial value.
+                def.node.init &&
+                // It does not write new values.
+                (def.parent.kind === "const" ||
+                    variable.references.every(
+                        (ref) =>
+                            ref.isReadOnly() || ref.identifier === def.name,
+                    ))
+            ) {
+                // The type of the initial value is the type of the variable.
+                const init = getTypeInfo(def.node.init)
+                return init && getPatternTypeInfo(def.name, def.node.id, init)
             }
+        } else if (def.type === "FunctionName") {
+            return getTypeInfo(def.node)
         }
         return null
     }
@@ -301,15 +214,15 @@ function buildExpressionTypeProviderImpl(context) {
      *   | import("estree").AssignmentOperator} operator
      * @param {import("estree").Expression} leftNode
      * @param {import("estree").Expression} rightNode
-     * @returns {TypeName | null}
+     * @returns {TypeInfo | null}
      */
     // eslint-disable-next-line complexity
-    function getOperatorType(operator, leftNode, rightNode) {
+    function getOperatorTypeInfo(operator, leftNode, rightNode) {
         if (operator === "=") {
-            return getType(rightNode)
+            return getTypeInfo(rightNode)
         }
         if (operator === "+" || operator === "+=") {
-            return getPlusOperatorType(leftNode, rightNode)
+            return getPlusOperatorTypeInfo(leftNode, rightNode)
         }
         if (
             operator === "==" ||
@@ -323,7 +236,7 @@ function buildExpressionTypeProviderImpl(context) {
             operator === "in" ||
             operator === "instanceof"
         ) {
-            return "Boolean"
+            return { type: "Boolean" }
         }
         if (
             operator === "-" ||
@@ -343,12 +256,14 @@ function buildExpressionTypeProviderImpl(context) {
             operator === "|" ||
             operator === "|="
         ) {
-            const left = getType(leftNode)
-            const right = getType(rightNode)
-            if (left === "BigInt" || right === "BigInt") {
-                return "BigInt"
+            const left = getTypeInfo(leftNode)
+            const right = getTypeInfo(rightNode)
+            if (left?.type === "BigInt" || right?.type === "BigInt") {
+                return { type: "BigInt" }
             }
-            return left == null && right == null ? null : "Number"
+            return left?.type == null && right?.type == null
+                ? null
+                : { type: "Number" }
         }
         if (
             operator === "<<" ||
@@ -358,7 +273,7 @@ function buildExpressionTypeProviderImpl(context) {
             operator === ">>>" ||
             operator === ">>>="
         ) {
-            return "Number"
+            return { type: "Number" }
         }
         if (
             operator === "&&" ||
@@ -368,9 +283,11 @@ function buildExpressionTypeProviderImpl(context) {
             operator === "??" ||
             operator === "??="
         ) {
-            const left = getType(leftNode)
-            const right = getType(rightNode)
-            return left === right ? left : null
+            const left = getTypeInfo(leftNode)
+            const right = getTypeInfo(rightNode)
+            return left?.type && left.type === right?.type
+                ? { type: left.type }
+                : null
         }
         return null
     }
@@ -378,100 +295,236 @@ function buildExpressionTypeProviderImpl(context) {
     /**
      * @param {import("estree").Expression} leftNode
      * @param {import("estree").Expression} rightNode
-     * @returns {TypeName | null}
+     * @returns {TypeInfo | null}
      */
-    function getPlusOperatorType(leftNode, rightNode) {
-        const left = getType(leftNode)
-        const right = getType(rightNode)
-        if (left === "String" || right === "String") {
-            return "String"
+    // eslint-disable-next-line complexity
+    function getPlusOperatorTypeInfo(leftNode, rightNode) {
+        const left = getTypeInfo(leftNode)
+        const right = getTypeInfo(rightNode)
+        if (left?.type === "String" || right?.type === "String") {
+            return { type: "String" }
         }
-        if (left === "BigInt" || right === "BigInt") {
-            return "BigInt"
+        if (left?.type === "BigInt" || right?.type === "BigInt") {
+            return { type: "BigInt" }
         }
-        if (right === "Number") {
-            return "Number"
+        if (right?.type === "Number") {
+            return { type: "Number" }
         }
-        if (left === "Number") {
-            if (right === "null" || right === "undefined") {
-                return "Number"
+        if (left?.type === "Number") {
+            if (right?.type === "null" || right?.type === "undefined") {
+                return { type: "Number" }
             }
         }
         if (right == null) {
             return null
         }
-        return "String"
+        return { type: "String" }
     }
 
     /**
      * @param {import("estree").UnaryExpression} node
-     * @returns {TypeName | null}
+     * @returns {TypeInfo | null}
      */
-    function getUnaryExpressionType(node) {
+    function getUnaryExpressionTypeInfo(node) {
         if (node.operator === "!" || node.operator === "delete") {
-            return "Boolean"
+            return { type: "Boolean" }
         }
         if (node.operator === "+") {
-            return "Number"
+            return { type: "Number" }
         }
         if (node.operator === "-" || node.operator === "~") {
-            const argument = getType(node.argument)
-            if (argument === "BigInt") {
-                return argument
+            const argument = getTypeInfo(node.argument)
+            if (argument?.type === "BigInt") {
+                return { type: "BigInt" }
             }
-            return argument == null ? null : "Number"
+            return argument == null ? null : { type: "Number" }
         }
         if (node.operator === "typeof") {
-            return "String"
+            return { type: "String" }
         }
         if (node.operator === "void") {
-            return "undefined"
+            return { type: "undefined" }
         }
         return null
     }
 
     /**
      * @param {import("estree").SimpleCallExpression | import("estree").NewExpression | import("estree").TaggedTemplateExpression} node
-     * @returns {TypeName | null}
+     * @returns {TypeInfo | null}
      */
-
-    function getCallExpressionType(node) {
+    function getCallExpressionTypeInfo(node) {
         const callee =
             node.type === "CallExpression" || node.type === "NewExpression"
                 ? node.callee
                 : node.tag
-        if (callee.type === "Identifier") {
-            if (!isGlobalObject(callee)) {
-                return null
-            }
-            const obj = WELLKNOWN_GLOBALS[callee.name]
-            return obj?.type === "Function" ? obj.returnType : null
-        } else if (callee.type === "MemberExpression") {
-            if (
-                callee.computed ||
-                callee.property.type !== "Identifier" ||
-                !isGlobalObject(callee.object)
-            ) {
-                return null
-            }
-            const obj = WELLKNOWN_GLOBALS[callee.object.name]
-            if (obj?.type === "Object") {
-                const prop = obj.properties[callee.property.name]
-                return prop?.type === "Function" ? prop.returnType : null
-            }
+        return getTypeInfo(callee)?.return ?? null
+    }
+
+    /**
+     * @param {FunctionExpression|ArrowFunctionExpression|FunctionDeclaration} node
+     * @returns {TypeInfo | null}
+     */
+    function getFunctionTypeInfo(node) {
+        return {
+            type: "Function",
+            get return() {
+                if (node.async) {
+                    return { type: "Promise" }
+                }
+                if (node.generator) {
+                    return { type: "Iterator" }
+                }
+                if (node.body.type !== "BlockStatement") {
+                    return getTypeInfo(node.body)
+                }
+                /** @type { TypeInfo | null} */
+                let returnStatement = null
+                for (const st of iterateReturn(node.body.body)) {
+                    if (!st.argument) {
+                        continue
+                    }
+                    const argument = getTypeInfo(st.argument)
+                    if (!returnStatement) {
+                        returnStatement = argument
+                    } else if (returnStatement.type === argument.type) {
+                        /** @type {TypeInfo} */
+                        const base = returnStatement
+                        // Merge return type
+                        returnStatement = {
+                            type: base.type,
+                            get return() {
+                                const type1 = base.return?.type
+                                const type2 = argument.return?.type
+                                if (!type1 || !type2 || type1 !== type2) {
+                                    return null
+                                }
+                                return {
+                                    type: type1,
+                                }
+                            },
+                        }
+                    } else {
+                        return null
+                    }
+                }
+
+                return returnStatement
+
+                /**
+                 * @param {import('estree').Statement[]} statements
+                 */
+                // eslint-disable-next-line complexity
+                function* iterateReturn(statements) {
+                    for (const statement of statements) {
+                        if (statement.type === "ReturnStatement") {
+                            yield statement
+                        } else if (statement.type === "BlockStatement") {
+                            yield* iterateReturn(statement.body)
+                        } else if (
+                            statement.type === "LabeledStatement" ||
+                            statement.type === "WithStatement" ||
+                            statement.type === "ForStatement" ||
+                            statement.type === "ForInStatement" ||
+                            statement.type === "ForOfStatement" ||
+                            statement.type === "WhileStatement" ||
+                            statement.type === "DoWhileStatement"
+                        ) {
+                            yield* iterateReturn([statement.body])
+                        } else if (statement.type === "IfStatement") {
+                            yield* iterateReturn([statement.consequent])
+                            if (statement.alternate) {
+                                yield* iterateReturn([statement.alternate])
+                            }
+                        } else if (statement.type === "SwitchStatement") {
+                            for (const caseClause of statement.cases) {
+                                yield* iterateReturn(caseClause.consequent)
+                            }
+                        } else if (statement.type === "TryStatement") {
+                            yield* iterateReturn([statement.block])
+                            if (statement.handler) {
+                                yield* iterateReturn([statement.handler.body])
+                            }
+                            if (statement.finalizer) {
+                                yield* iterateReturn([statement.finalizer])
+                            }
+                        }
+                    }
+                }
+            },
         }
-        return null
     }
 
     /**
-     * @param {import("estree").Node} node
-     * @returns {node is import("estree").Identifier}
+     * @param {import('estree').MemberExpression} node
+     * @returns {TypeInfo | null}
      */
-    function isGlobalObject(node) {
-        if (node.type !== "Identifier") {
-            return false
+    function getMemberExpressionTypeInfo(node) {
+        const propertyName = getPropertyName(
+            node,
+            getSourceCode(context).getScope(node),
+        )
+        if (propertyName == null) {
+            return null
         }
-        const variable = findVariableFromIdentifier(node)
-        return Boolean(variable && variable.defs.length === 0)
+        const object = getTypeInfo(node.object)
+        if (!object) {
+            return null
+        }
+        return getPropertyType(object, propertyName)
+    }
+
+    /**
+     * @param {import('estree').Identifier} id
+     * @param {import('estree').Pattern} pattern
+     * @param {TypeInfo} expression
+     * @returns {TypeInfo | null}
+     */
+    function getPatternTypeInfo(id, pattern, expression) {
+        if (pattern.type === "Identifier") {
+            return pattern === id ? expression : null
+        }
+        if (pattern.type === "ObjectPattern") {
+            for (const prop of pattern.properties) {
+                if (prop.type !== "Property") {
+                    continue
+                }
+                const propertyName = getPropertyName(
+                    prop,
+                    getSourceCode(context).getScope(pattern),
+                )
+                if (propertyName == null) {
+                    continue
+                }
+                const property = getPropertyType(expression, propertyName)
+                if (property == null) {
+                    continue
+                }
+                const patternType = getPatternTypeInfo(id, prop.value, property)
+                if (patternType != null) {
+                    return patternType
+                }
+            }
+            return null
+        }
+        if (pattern.type === "ArrayPattern") {
+            for (const [index, entry] of pattern.elements.entries()) {
+                if (!entry) {
+                    continue
+                }
+                const indexType = getPropertyType(expression, index)
+                if (indexType == null) {
+                    continue
+                }
+                const patternType = getPatternTypeInfo(id, entry, indexType)
+                if (patternType != null) {
+                    return patternType
+                }
+            }
+            return null
+        }
+        if (pattern.type === "AssignmentPattern") {
+            return getPatternTypeInfo(id, pattern.left, expression)
+        }
+        return null
     }
 }
diff --git a/lib/util/define-prototype-method-handler/types.d.ts b/lib/util/define-prototype-method-handler/types.d.ts
new file mode 100644
index 0000000..0b58927
--- /dev/null
+++ b/lib/util/define-prototype-method-handler/types.d.ts
@@ -0,0 +1,163 @@
+export type TypeName =
+  | "Array"
+  | "Date"
+  | "Function"
+  | "Intl.Collator"
+  | "Intl.DateTimeFormat"
+  | "Intl.ListFormat"
+  | "Intl.NumberFormat"
+  | "Intl.PluralRules"
+  | "Intl.RelativeTimeFormat"
+  | "Intl.Segmenter"
+  | "Intl.DisplayNames"
+  | "Intl.Locale"
+  | "Promise"
+  | "RegExp"
+  | "String"
+  | "Symbol"
+  | "Int8Array"
+  | "Uint8Array"
+  | "Uint8ClampedArray"
+  | "Int16Array"
+  | "Uint16Array"
+  | "Int32Array"
+  | "Uint32Array"
+  | "Float32Array"
+  | "Float64Array"
+  | "BigInt64Array"
+  | "BigUint64Array"
+  | "ArrayBuffer"
+  | "SharedArrayBuffer"
+  | "Object"
+  | "Number"
+  | "Boolean"
+  | "BigInt"
+  | "Iterator"
+  | "null"
+  | "undefined";
+
+type TypeInfo = {
+  type: TypeName;
+  return?: TypeInfo;
+  properties?: Record<string, TypeInfo | undefined>;
+};
+
+export type WellKnownGlobals = Record<string, TypeInfo | undefined>;
+
+export type WellKnownPrototypes = Record<
+  string,
+  Record<string, TypeInfo | undefined> | undefined
+>;
+
+type ExcludeProperty = "prototype" | typeof Symbol.species;
+type ExcludePrototypeProperty =
+  | "toString"
+  | "toLocaleString"
+  | typeof Symbol.iterator
+  | typeof Symbol.toPrimitive
+  | typeof Symbol.toStringTag
+  | typeof Symbol.hasInstance
+  | typeof Symbol.unscopables
+  | typeof Symbol.match
+  | typeof Symbol.replace
+  | typeof Symbol.search
+  | typeof Symbol.split
+  | typeof Symbol.matchAll
+  | typeof Symbol.species
+  | typeof Symbol.dispose
+  | typeof Symbol.metadata;
+
+export type ObjectProperty = keyof typeof Object;
+export type ObjectPrototypeProperty = keyof Object;
+export type StringProperty = Exclude<keyof typeof String, ExcludeProperty>;
+export type StringPrototypeProperty = Exclude<
+  keyof String,
+  ExcludePrototypeProperty
+>;
+export type NumberProperty = Exclude<keyof typeof Number, ExcludeProperty>;
+export type NumberPrototypeProperty = Exclude<
+  keyof Number,
+  ExcludePrototypeProperty
+>;
+export type BooleanProperty = Exclude<keyof typeof Boolean, ExcludeProperty>;
+export type BooleanPrototypeProperty = Exclude<
+  keyof Boolean,
+  ExcludePrototypeProperty
+>;
+export type SymbolProperty = Exclude<keyof typeof Symbol, ExcludeProperty>;
+export type SymbolPrototypeProperty = Exclude<
+  keyof Symbol,
+  ExcludePrototypeProperty
+>;
+export type BigIntProperty = Exclude<keyof typeof BigInt, ExcludeProperty>;
+export type BigIntPrototypeProperty = Exclude<
+  keyof BigInt,
+  ExcludePrototypeProperty
+>;
+export type FunctionProperty = Exclude<keyof typeof Function, ExcludeProperty>;
+export type FunctionPrototypeProperty = Exclude<
+  keyof Function,
+  ExcludePrototypeProperty
+>;
+export type ArrayProperty = Exclude<keyof typeof Array, ExcludeProperty>;
+export type ArrayPrototypeProperty = Exclude<
+  keyof Array<any>,
+  ExcludePrototypeProperty
+>;
+export type RegExpProperty = Exclude<keyof typeof RegExp, ExcludeProperty>;
+export type RegExpPrototypeProperty = Exclude<
+  keyof RegExp,
+  ExcludePrototypeProperty
+>;
+export type RegExpArrayPrototypeProperty = Exclude<
+  keyof RegExpExecArray,
+  ExcludePrototypeProperty
+>;
+export type DateProperty = Exclude<keyof typeof Date, ExcludeProperty>;
+export type DatePrototypeProperty =
+  | Exclude<keyof Date, ExcludePrototypeProperty | "getVarDate">
+  | "getYear"
+  | "setYear"
+  | "toGMTString";
+export type PromiseProperty =
+  | Exclude<keyof typeof Promise, ExcludeProperty>
+  | "try";
+export type PromisePrototypeProperty = Exclude<
+  keyof Promise<any>,
+  ExcludePrototypeProperty
+>;
+export type ArrayBufferProperty = Exclude<
+  keyof typeof ArrayBuffer,
+  ExcludeProperty
+>;
+export type ArrayBufferPrototypeProperty =
+  | Exclude<keyof ArrayBuffer, ExcludePrototypeProperty>
+  | "resize"
+  | "transfer"
+  | "transferToFixedLength"
+  | "detached"
+  | "maxByteLength"
+  | "resizable";
+export type SharedArrayBufferProperty = Exclude<
+  keyof typeof SharedArrayBuffer,
+  ExcludeProperty
+>;
+export type SharedArrayBufferPrototypeProperty =
+  | Exclude<keyof SharedArrayBuffer, ExcludePrototypeProperty>
+  | "grow"
+  | "growable"
+  | "maxByteLength";
+export type IntlProperty = Exclude<keyof typeof Intl, ExcludeProperty>;
+export type IteratorProperty = Exclude<keyof typeof Iterator, ExcludeProperty>;
+export type IteratorPrototypeProperty = Exclude<
+  keyof IteratorObject<any>,
+  ExcludePrototypeProperty
+>;
+export type TypedArrayProperty = Exclude<
+  keyof typeof Int8Array,
+  ExcludeProperty
+>;
+export type TypedArrayPrototypeProperty = Exclude<
+  keyof Int8Array,
+  ExcludePrototypeProperty | "BYTES_PER_ELEMENT"
+>;
diff --git a/package.json b/package.json
index ef3b149..36ff001 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,7 @@
     "opener": "^1.5.1",
     "rimraf": "^6.0.0",
     "semver": "^7.0.0",
-    "typescript": "^5.0.2",
+    "typescript": "^5.6.3",
     "vite-plugin-eslint4b": "^0.4.0",
     "vitepress": "^1.0.0-rc.14",
     "vue-eslint-editor": "^1.1.0",
diff --git a/scripts/proposals.js b/scripts/proposals.js
index 790b063..55c4b4d 100644
--- a/scripts/proposals.js
+++ b/scripts/proposals.js
@@ -13,6 +13,10 @@ module.exports = {
         title: "Class Fields",
         link: "https://github.com/tc39/proposal-class-fields",
     },
+    "import-attributes": {
+        title: "Import Attributes",
+        link: "https://github.com/tc39/proposal-import-attributes",
+    },
     "intl-numberformat-v3": {
         title: "Intl.NumberFormat V3",
         link: "https://github.com/tc39/proposal-intl-numberformat-v3",
@@ -21,6 +25,10 @@ module.exports = {
         title: "Well-Formed Unicode Strings",
         link: "https://github.com/tc39/proposal-is-usv-string",
     },
+    "iterator-helpers": {
+        title: "Iterator Helpers",
+        link: "https://github.com/tc39/proposal-iterator-helpers",
+    },
     "relative-indexing-method": {
         title: "An .at() method on all the built-in indexables",
         link: "https://github.com/tc39/proposal-relative-indexing-method",
@@ -29,8 +37,4 @@ module.exports = {
         title: "Set Methods for JavaScript",
         link: "https://github.com/tc39/proposal-set-methods",
     },
-    "import-attributes": {
-        title: "Import Attributes",
-        link: "https://github.com/tc39/proposal-import-attributes",
-    },
 }


Test patch:
diff --git a/tests/fixtures/tsconfig.json b/tests/fixtures/tsconfig.json
index 2f2cd23..b843eb5 100644
--- a/tests/fixtures/tsconfig.json
+++ b/tests/fixtures/tsconfig.json
@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "strict": true,
-        "lib": ["ES2021"]
+        "lib": ["ESNext"]
     },
     "include": ["test.ts"]
 }
diff --git a/tests/lib/rules/no-iterator-prototype-drop.js b/tests/lib/rules/no-iterator-prototype-drop.js
new file mode 100644
index 0000000..358ab24
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-drop.js
@@ -0,0 +1,220 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-drop.js")
+const ruleId = "no-iterator-prototype-drop"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "drop(3)",
+        "foo.unknown(0)",
+        "foo.drop(3)",
+        {
+            code: "drop(3)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.drop(3)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().drop(3);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().drop(3);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().drop(3);
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.drop(3)",
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.drop(3)",
+            options: [{ aggressive: true }],
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().drop(3); function * foo() {  }",
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).drop(3);",
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).drop(3).drop(3);",
+            errors: [
+                "ES2025 'Iterator.prototype.drop' method is forbidden.",
+                "ES2025 'Iterator.prototype.drop' method is forbidden.",
+            ],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().drop(3)",
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().drop(3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().drop(3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().drop(3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().drop(3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().drop(3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "drop(3)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.drop(3)" },
+        {
+            filename,
+            code: "let foo = {}; foo.drop(3)",
+        },
+        {
+            filename,
+            code: "drop(3)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().drop(3)",
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.drop(3) }",
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().drop(3)",
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+        {
+            filename,
+            code: "foo.drop(3)",
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: '"s".matchAll(/a/g).drop(1)',
+            errors: ["ES2025 'Iterator.prototype.drop' method is forbidden."],
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator-prototype-every.js b/tests/lib/rules/no-iterator-prototype-every.js
new file mode 100644
index 0000000..b85f47c
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-every.js
@@ -0,0 +1,212 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-every.js")
+const ruleId = "no-iterator-prototype-every"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "every(n => n % 2)",
+        "foo.unknown(0)",
+        "foo.every(n => n % 2)",
+        {
+            code: "every(n => n % 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.every(n => n % 2)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().every(n => n % 2);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().every(n => n % 2);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().every(n => n % 2);
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.every(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.every(n => n % 2)",
+            options: [{ aggressive: true }],
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().every(n => n % 2); function * foo() {  }",
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).every(n => n % 2);",
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).drop(3).every(n => n % 2);",
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().every(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().every(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().every(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().every(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().every(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().every(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "every(n => n % 2)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.every(n => n % 2)" },
+        {
+            filename,
+            code: "let foo = {}; foo.every(n => n % 2)",
+        },
+        {
+            filename,
+            code: "every(n => n % 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().every(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.every(n => n % 2) }",
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().every(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+        },
+        {
+            filename,
+            code: "foo.every(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.every' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator-prototype-filter.js b/tests/lib/rules/no-iterator-prototype-filter.js
new file mode 100644
index 0000000..b9f4d24
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-filter.js
@@ -0,0 +1,212 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-filter.js")
+const ruleId = "no-iterator-prototype-filter"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "filter(n => n % 2)",
+        "foo.unknown(0)",
+        "foo.filter(n => n % 2)",
+        {
+            code: "filter(n => n % 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.filter(n => n % 2)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().filter(n => n % 2);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().filter(n => n % 2);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().filter(n => n % 2);
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.filter(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.filter(n => n % 2)",
+            options: [{ aggressive: true }],
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().filter(n => n % 2); function * foo() {  }",
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).filter(n => n % 2);",
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).drop(3).filter(n => n % 2);",
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().filter(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().filter(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().filter(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().filter(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().filter(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().filter(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "filter(n => n % 2)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.filter(n => n % 2)" },
+        {
+            filename,
+            code: "let foo = {}; foo.filter(n => n % 2)",
+        },
+        {
+            filename,
+            code: "filter(n => n % 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().filter(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.filter(n => n % 2) }",
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().filter(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+        },
+        {
+            filename,
+            code: "foo.filter(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.filter' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator-prototype-find.js b/tests/lib/rules/no-iterator-prototype-find.js
new file mode 100644
index 0000000..bdc74ed
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-find.js
@@ -0,0 +1,212 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-find.js")
+const ruleId = "no-iterator-prototype-find"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "find(n => n % 2)",
+        "foo.unknown(0)",
+        "foo.find(n => n % 2)",
+        {
+            code: "find(n => n % 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.find(n => n % 2)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().find(n => n % 2);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().find(n => n % 2);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().find(n => n % 2);
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.find(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.find(n => n % 2)",
+            options: [{ aggressive: true }],
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().find(n => n % 2); function * foo() {  }",
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).find(n => n % 2);",
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).drop(3).find(n => n % 2);",
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().find(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().find(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().find(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().find(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().find(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().find(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "find(n => n % 2)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.find(n => n % 2)" },
+        {
+            filename,
+            code: "let foo = {}; foo.find(n => n % 2)",
+        },
+        {
+            filename,
+            code: "find(n => n % 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().find(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.find(n => n % 2) }",
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().find(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+        },
+        {
+            filename,
+            code: "foo.find(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.find' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator-prototype-flatmap.js b/tests/lib/rules/no-iterator-prototype-flatmap.js
new file mode 100644
index 0000000..9490e17
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-flatmap.js
@@ -0,0 +1,242 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-flatmap.js")
+const ruleId = "no-iterator-prototype-flatmap"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "flatMap(n => [n, -n])",
+        "foo.unknown(0)",
+        "foo.flatMap(n => [n, -n])",
+        {
+            code: "flatMap(n => [n, -n])",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.flatMap(n => [n, -n])",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().flatMap(n => [n, -n]);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().flatMap(n => [n, -n]);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().flatMap(n => [n, -n]);
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.flatMap(n => [n, -n])",
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.flatMap(n => [n, -n])",
+            options: [{ aggressive: true }],
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().flatMap(n => [n, -n]); function * foo() {  }",
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            code: "Iterator.from(foo).flatMap(n => [n, -n]);",
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            code: "Iterator.from(foo).drop(3).flatMap(n => [n, -n]);",
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().flatMap(n => [n, -n])",
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().flatMap(n => [n, -n]);
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().flatMap(n => [n, -n]);
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().flatMap(n => [n, -n]);
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().flatMap(n => [n, -n]);
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().flatMap(n => [n, -n]);
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "flatMap(n => [n, -n])" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.flatMap(n => [n, -n])" },
+        {
+            filename,
+            code: "let foo = {}; foo.flatMap(n => [n, -n])",
+        },
+        {
+            filename,
+            code: "flatMap(n => [n, -n])",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().flatMap(n => [n, -n])",
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.flatMap(n => [n, -n]) }",
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().flatMap(n => [n, -n])",
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "foo.flatMap(n => [n, -n])",
+            errors: [
+                "ES2025 'Iterator.prototype.flatMap' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator-prototype-foreach.js b/tests/lib/rules/no-iterator-prototype-foreach.js
new file mode 100644
index 0000000..3b91c17
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-foreach.js
@@ -0,0 +1,242 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-foreach.js")
+const ruleId = "no-iterator-prototype-foreach"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "forEach(n => {/* ... */})",
+        "foo.unknown(0)",
+        "foo.forEach(n => {/* ... */})",
+        {
+            code: "forEach(n => {/* ... */})",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.forEach(n => {/* ... */})",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().forEach(n => {/* ... */});
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().forEach(n => {/* ... */});
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().forEach(n => {/* ... */});
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.forEach(n => {/* ... */})",
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.forEach(n => {/* ... */})",
+            options: [{ aggressive: true }],
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().forEach(n => {/* ... */}); function * foo() {  }",
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            code: "Iterator.from(foo).forEach(n => {/* ... */});",
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            code: "Iterator.from(foo).drop(3).forEach(n => {/* ... */});",
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().forEach(n => {/* ... */})",
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().forEach(n => {/* ... */});
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().forEach(n => {/* ... */});
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().forEach(n => {/* ... */});
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().forEach(n => {/* ... */});
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().forEach(n => {/* ... */});
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "forEach(n => {/* ... */})" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.forEach(n => {/* ... */})" },
+        {
+            filename,
+            code: "let foo = {}; foo.forEach(n => {/* ... */})",
+        },
+        {
+            filename,
+            code: "forEach(n => {/* ... */})",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().forEach(n => {/* ... */})",
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.forEach(n => {/* ... */}) }",
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().forEach(n => {/* ... */})",
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "foo.forEach(n => {/* ... */})",
+            errors: [
+                "ES2025 'Iterator.prototype.forEach' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator-prototype-map.js b/tests/lib/rules/no-iterator-prototype-map.js
new file mode 100644
index 0000000..64976b8
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-map.js
@@ -0,0 +1,212 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-map.js")
+const ruleId = "no-iterator-prototype-map"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "map(n => n % 2)",
+        "foo.unknown(0)",
+        "foo.map(n => n % 2)",
+        {
+            code: "map(n => n % 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.map(n => n % 2)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().map(n => n % 2);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().map(n => n % 2);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().map(n => n % 2);
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.map(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.map(n => n % 2)",
+            options: [{ aggressive: true }],
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().map(n => n % 2); function * foo() {  }",
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).map(n => n % 2);",
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).drop(3).map(n => n % 2);",
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().map(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().map(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().map(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().map(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().map(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().map(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "map(n => n % 2)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.map(n => n % 2)" },
+        {
+            filename,
+            code: "let foo = {}; foo.map(n => n % 2)",
+        },
+        {
+            filename,
+            code: "map(n => n % 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().map(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.map(n => n % 2) }",
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().map(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+        },
+        {
+            filename,
+            code: "foo.map(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.map' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator-prototype-reduce.js b/tests/lib/rules/no-iterator-prototype-reduce.js
new file mode 100644
index 0000000..4befe80
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-reduce.js
@@ -0,0 +1,212 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-reduce.js")
+const ruleId = "no-iterator-prototype-reduce"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "reduce((sum, value) => sum + value, 3)",
+        "foo.unknown(0)",
+        "foo.reduce((sum, value) => sum + value, 3)",
+        {
+            code: "reduce((sum, value) => sum + value, 3)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.reduce((sum, value) => sum + value, 3)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().reduce((sum, value) => sum + value, 3);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().reduce((sum, value) => sum + value, 3);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().reduce((sum, value) => sum + value, 3);
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.reduce((sum, value) => sum + value, 3)",
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.reduce((sum, value) => sum + value, 3)",
+            options: [{ aggressive: true }],
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().reduce((sum, value) => sum + value, 3); function * foo() {  }",
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).reduce((sum, value) => sum + value, 3);",
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).drop(3).reduce((sum, value) => sum + value, 3);",
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().reduce((sum, value) => sum + value, 3)",
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().reduce((sum, value) => sum + value, 3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().reduce((sum, value) => sum + value, 3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().reduce((sum, value) => sum + value, 3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().reduce((sum, value) => sum + value, 3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().reduce((sum, value) => sum + value, 3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "reduce((sum, value) => sum + value, 3)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.reduce((sum, value) => sum + value, 3)" },
+        {
+            filename,
+            code: "let foo = {}; foo.reduce((sum, value) => sum + value, 3)",
+        },
+        {
+            filename,
+            code: "reduce((sum, value) => sum + value, 3)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().reduce((sum, value) => sum + value, 3)",
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.reduce((sum, value) => sum + value, 3) }",
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().reduce((sum, value) => sum + value, 3)",
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+        },
+        {
+            filename,
+            code: "foo.reduce((sum, value) => sum + value, 3)",
+            errors: ["ES2025 'Iterator.prototype.reduce' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator-prototype-some.js b/tests/lib/rules/no-iterator-prototype-some.js
new file mode 100644
index 0000000..98fd890
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-some.js
@@ -0,0 +1,212 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-some.js")
+const ruleId = "no-iterator-prototype-some"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "some(n => n % 2)",
+        "foo.unknown(0)",
+        "foo.some(n => n % 2)",
+        {
+            code: "some(n => n % 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.some(n => n % 2)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().some(n => n % 2);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().some(n => n % 2);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().some(n => n % 2);
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.some(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.some(n => n % 2)",
+            options: [{ aggressive: true }],
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().some(n => n % 2); function * foo() {  }",
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).some(n => n % 2);",
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).drop(3).some(n => n % 2);",
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().some(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().some(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().some(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().some(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().some(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().some(n => n % 2);
+            `,
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "some(n => n % 2)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.some(n => n % 2)" },
+        {
+            filename,
+            code: "let foo = {}; foo.some(n => n % 2)",
+        },
+        {
+            filename,
+            code: "some(n => n % 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().some(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.some(n => n % 2) }",
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().some(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+        },
+        {
+            filename,
+            code: "foo.some(n => n % 2)",
+            errors: ["ES2025 'Iterator.prototype.some' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator-prototype-take.js b/tests/lib/rules/no-iterator-prototype-take.js
new file mode 100644
index 0000000..87b01c4
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-take.js
@@ -0,0 +1,215 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-take.js")
+const ruleId = "no-iterator-prototype-take"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "take(3)",
+        "foo.unknown(0)",
+        "foo.take(3)",
+        {
+            code: "take(3)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.take(3)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().take(3);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().take(3);
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().take(3);
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.take(3)",
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.take(3)",
+            options: [{ aggressive: true }],
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().take(3); function * foo() {  }",
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).take(3);",
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+        {
+            code: "Iterator.from(foo).take(3).take(3);",
+            errors: [
+                "ES2025 'Iterator.prototype.take' method is forbidden.",
+                "ES2025 'Iterator.prototype.take' method is forbidden.",
+            ],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().take(3)",
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().take(3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().take(3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().take(3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().take(3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().take(3);
+            `,
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "take(3)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.take(3)" },
+        {
+            filename,
+            code: "let foo = {}; foo.take(3)",
+        },
+        {
+            filename,
+            code: "take(3)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().take(3)",
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.take(3) }",
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().take(3)",
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+        },
+        {
+            filename,
+            code: "foo.take(3)",
+            errors: ["ES2025 'Iterator.prototype.take' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator-prototype-toarray.js b/tests/lib/rules/no-iterator-prototype-toarray.js
new file mode 100644
index 0000000..e766750
--- /dev/null
+++ b/tests/lib/rules/no-iterator-prototype-toarray.js
@@ -0,0 +1,242 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator-prototype-toarray.js")
+const ruleId = "no-iterator-prototype-toarray"
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log(`Skip the tests of ${ruleId}.`)
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run(ruleId, rule, {
+    valid: [
+        "toArray()",
+        "foo.unknown(0)",
+        "foo.toArray()",
+        {
+            code: "toArray()",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.toArray()",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+        `
+        function * foo(){};
+        function bar() {
+            if (baz) return foo();
+            else return "s"
+        };
+        bar().toArray();
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            switch (baz) {
+                case 1: return foo();
+                default: return "s"
+            }
+        };
+        bar().toArray();
+        `,
+        `
+        function * foo(){};
+        function bar() {
+            try {
+                return foo();
+            } catch (e) {
+                return Iterator.from(x)
+            } finally {
+                return "s"
+            }
+        };
+        bar().toArray();
+    `,
+    ],
+    invalid: [
+        {
+            code: "foo.toArray()",
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.toArray()",
+            options: [{ aggressive: true }],
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: false } },
+        },
+        {
+            code: "foo().toArray(); function * foo() {  }",
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            code: "Iterator.from(foo).toArray();",
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            code: "Iterator.from(foo).drop(3).toArray();",
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            code: "function * foo(){}; function bar() { return foo() }; bar().toArray()",
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                if (baz) return foo();
+                else return Iterator.from(x)
+              };
+              bar().toArray();
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                while(true) return foo();
+              };
+              bar().toArray();
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                switch (baz) {
+                    case 1: return foo();
+                    default: return Iterator.from(x)
+                }
+              };
+              bar().toArray();
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              function bar() {
+                try {
+                  return foo();
+                } catch (e) {
+                  return Iterator.from(x)
+                } finally {
+                  return Iterator.from(y)
+                }
+              };
+              bar().toArray();
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            code: `
+              function * foo(){};
+              const bar = () => foo();
+              bar().toArray();
+            `,
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({
+    languageOptions: {
+        parser,
+        parserOptions: {
+            tsconfigRootDir,
+            project,
+            disallowAutomaticSingleRunInference: true,
+        },
+    },
+}).run(`${ruleId} TS Full Type Information`, rule, {
+    valid: [
+        { filename, code: "toArray()" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.toArray()" },
+        {
+            filename,
+            code: "let foo = {}; foo.toArray()",
+        },
+        {
+            filename,
+            code: "toArray()",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = [][Symbol.iterator]; foo().toArray()",
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "function f(a: Iterator<any>) { a.toArray() }",
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "function * foo(){}; foo().toArray()",
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "foo.toArray()",
+            errors: [
+                "ES2025 'Iterator.prototype.toArray' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-iterator.js b/tests/lib/rules/no-iterator.js
new file mode 100644
index 0000000..19670a6
--- /dev/null
+++ b/tests/lib/rules/no-iterator.js
@@ -0,0 +1,29 @@
+"use strict"
+
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-iterator.js")
+
+if (!RuleTester.isSupported(2025)) {
+    //eslint-disable-next-line no-console
+    console.log("Skip the tests of no-iterator.")
+    return
+}
+
+new RuleTester({
+    languageOptions: { globals: { Iterator: "readonly" } },
+}).run("no-iterator", rule, {
+    valid: [
+        "Array.from(object)",
+        "const Iterator = Array; Iterator.from(object)",
+    ],
+    invalid: [
+        {
+            code: "Iterator.from(object)",
+            errors: ["ES2025 'Iterator' class is forbidden."],
+        },
+        {
+            code: "Iterator",
+            errors: ["ES2025 'Iterator' class is forbidden."],
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-promise-try.js b/tests/lib/rules/no-promise-try.js
new file mode 100644
index 0000000..2187e62
--- /dev/null
+++ b/tests/lib/rules/no-promise-try.js
@@ -0,0 +1,18 @@
+/**
+ * @author Yosuke Ota
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-promise-try.js")
+
+new RuleTester().run("no-promise-try", rule, {
+    valid: ["Promise.all"],
+    invalid: [
+        {
+            code: "Promise.try",
+            errors: ["ES2025 'Promise.try' is forbidden."],
+        },
+    ],
+})
diff --git a/tests/lib/rules/no-symbol-prototype-description.js b/tests/lib/rules/no-symbol-prototype-description.js
index 46628cf..50c6520 100644
--- a/tests/lib/rules/no-symbol-prototype-description.js
+++ b/tests/lib/rules/no-symbol-prototype-description.js
@@ -12,7 +12,6 @@ const ruleId = "no-symbol-prototype-description"
 new RuleTester().run(ruleId, rule, {
     valid: [
         "foo.description",
-        "Symbol.iterator.description",
         {
             code: "foo.description",
             options: [{ aggressive: false }],
@@ -41,6 +40,12 @@ new RuleTester().run(ruleId, rule, {
             ],
             settings: { "es-x": { aggressive: false } },
         },
+        {
+            code: "Symbol.iterator.description",
+            errors: [
+                "ES2019 'Symbol.prototype.description' property is forbidden.",
+            ],
+        },
     ],
 })
 
diff --git a/tests/lib/util/define-prototype-method-handler/object-type-checker.js b/tests/lib/util/define-prototype-method-handler/object-type-checker.js
index 3648e12..e415a9c 100644
--- a/tests/lib/util/define-prototype-method-handler/object-type-checker.js
+++ b/tests/lib/util/define-prototype-method-handler/object-type-checker.js
@@ -22,7 +22,7 @@ if (!RuleTester.isSupported(2022)) {
 
 describe("define-prototype-method-handler/object-type-checker", () => {
     describe("buildExpressionTypeProvider", () => {
-        for (const { code, result } of [
+        for (const { code, result, only } of [
             {
                 code: "target('foo');",
                 result: ["String"],
@@ -408,8 +408,38 @@ describe("define-prototype-method-handler/object-type-checker", () => {
                 `,
                 result: ["Number", "Number"],
             },
+            {
+                code: `
+                target("".length);
+                `,
+                result: ["Number"],
+            },
+            {
+                code: `
+                target(
+                    String.fromCharCode(42),
+                    String.fromCodePoint(42),
+                    String.raw\`\`,
+                );
+                `,
+                result: ["String", "String", "String"],
+            },
+            {
+                code: `
+                const { promise, resolve, reject } = Promise.withResolvers()
+                target(promise, resolve, reject);
+                `,
+                result: ["Promise", "Function", "Function"],
+            },
+            {
+                code: `
+                const r = /foo/.exec('foo')[0]
+                target(r);
+                `,
+                result: ["String"],
+            },
         ]) {
-            it(code, () => {
+            ;(only ? it.only : it)(code, () => {
                 deepStrictEqual(
                     getResultOfBuildExpressionTypeProvider(code),
                     result,