Repository: eslint-community/eslint-plugin-es-x
Pull request #61 (2023-02-02 23:56:48)

Add rules for Intl.NumberFormat V3 methods
"[Intl.NumberFormat V3](https://github.com/tc39/proposal-intl-numberformat-v3)" is now Stage 4.
This PR adds 3 rules forbidding the prototype methods added in that proposal.

https://github.com/tc39/proposal-intl-numberformat-v3


Patch:
diff --git a/docs/rules/index.md b/docs/rules/index.md
index 8a1f8f2..e1dc66e 100644
--- a/docs/rules/index.md
+++ b/docs/rules/index.md
@@ -11,8 +11,22 @@ There is a config that enables the rules in this category: `plugin:es-x/no-new-i
 | Rule ID | Description |    |
 |:--------|:------------|:--:|
 | [es-x/no-array-prototype-findlast-findlastindex](./no-array-prototype-findlast-findlastindex.md) | disallow the `Array.prototype.{findLast,findLastIndex}` methods. |  |
+| [es-x/no-array-prototype-toreversed](./no-array-prototype-toreversed.md) | disallow the `Array.prototype.toReversed` method. |  |
+| [es-x/no-array-prototype-tosorted](./no-array-prototype-tosorted.md) | disallow the `Array.prototype.toSorted` method. |  |
+| [es-x/no-array-prototype-tospliced](./no-array-prototype-tospliced.md) | disallow the `Array.prototype.toSpliced` method. |  |
+| [es-x/no-array-prototype-with](./no-array-prototype-with.md) | disallow the `Array.prototype.with` method. |  |
 | [es-x/no-hashbang](./no-hashbang.md) | disallow Hashbang comments. |  |
 
+## ES2023 Intl API
+
+There is a config that enables the rules in this category: `plugin:es-x/no-new-in-esnext-intl-api`
+
+| Rule ID | Description |    |
+|:--------|:------------|:--:|
+| [es-x/no-intl-numberformat-prototype-formatrange](./no-intl-numberformat-prototype-formatrange.md) | disallow the `NumberFormat.prototype.formatRange` method. |  |
+| [es-x/no-intl-numberformat-prototype-formatrangetoparts](./no-intl-numberformat-prototype-formatrangetoparts.md) | disallow the `NumberFormat.prototype.formatRangeToParts` method. |  |
+| [es-x/no-intl-pluralrules-prototype-selectrange](./no-intl-pluralrules-prototype-selectrange.md) | disallow the `PluralRules.prototype.selectRange` method. |  |
+
 ## ES2022
 
 There are multiple configs that enable all rules in this category: `plugin:es-x/no-new-in-es2022`, `plugin:es-x/restrict-to-es3`, `plugin:es-x/restrict-to-es5`, `plugin:es-x/restrict-to-es2015`, `plugin:es-x/restrict-to-es2016`, `plugin:es-x/restrict-to-es2017`, `plugin:es-x/restrict-to-es2018`, `plugin:es-x/restrict-to-es2019`, `plugin:es-x/restrict-to-es2020`, and `plugin:es-x/restrict-to-es2021`
diff --git a/docs/rules/no-array-prototype-toreversed.md b/docs/rules/no-array-prototype-toreversed.md
new file mode 100644
index 0000000..c08991a
--- /dev/null
+++ b/docs/rules/no-array-prototype-toreversed.md
@@ -0,0 +1,46 @@
+---
+title: "es-x/no-array-prototype-toreversed"
+description: "disallow the `Array.prototype.toReversed` method"
+---
+
+# es-x/no-array-prototype-toreversed
+> disallow the `Array.prototype.toReversed` 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: `plugin:es-x/no-new-in-esnext`
+
+This rule reports ES2023 [`Array.prototype.toReversed` methods](https://github.com/tc39/proposal-change-array-by-copy) as errors.
+
+This rule is silent by default because it's hard to know types. You need to configure [the aggressive mode](../#the-aggressive-mode) or TypeScript in order to enable this rule.
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-array-prototype-toreversed: [error, { aggressive: true }] */
+array.toReversed()
+```
+
+</eslint-playground>
+
+## 🔧 Options
+
+This rule has an option.
+
+```yaml
+rules:
+  es-x/no-array-prototype-toreversed: [error, { aggressive: false }]
+```
+
+### aggressive: boolean
+
+Configure the aggressive mode for only this rule.
+This is prior to the `settings['es-x'].aggressive` setting.
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-array-prototype-toreversed.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-array-prototype-toreversed.js)
diff --git a/docs/rules/no-array-prototype-tosorted.md b/docs/rules/no-array-prototype-tosorted.md
new file mode 100644
index 0000000..e1277ad
--- /dev/null
+++ b/docs/rules/no-array-prototype-tosorted.md
@@ -0,0 +1,46 @@
+---
+title: "es-x/no-array-prototype-tosorted"
+description: "disallow the `Array.prototype.toSorted` method"
+---
+
+# es-x/no-array-prototype-tosorted
+> disallow the `Array.prototype.toSorted` 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: `plugin:es-x/no-new-in-esnext`
+
+This rule reports ES2023 [`Array.prototype.toSorted` methods](https://github.com/tc39/proposal-change-array-by-copy) as errors.
+
+This rule is silent by default because it's hard to know types. You need to configure [the aggressive mode](../#the-aggressive-mode) or TypeScript in order to enable this rule.
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-array-prototype-tosorted: [error, { aggressive: true }] */
+array.toSorted()
+```
+
+</eslint-playground>
+
+## 🔧 Options
+
+This rule has an option.
+
+```yaml
+rules:
+  es-x/no-array-prototype-tosorted: [error, { aggressive: false }]
+```
+
+### aggressive: boolean
+
+Configure the aggressive mode for only this rule.
+This is prior to the `settings['es-x'].aggressive` setting.
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-array-prototype-tosorted.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-array-prototype-tosorted.js)
diff --git a/docs/rules/no-array-prototype-tospliced.md b/docs/rules/no-array-prototype-tospliced.md
new file mode 100644
index 0000000..b6c733c
--- /dev/null
+++ b/docs/rules/no-array-prototype-tospliced.md
@@ -0,0 +1,46 @@
+---
+title: "es-x/no-array-prototype-tospliced"
+description: "disallow the `Array.prototype.toSpliced` method"
+---
+
+# es-x/no-array-prototype-tospliced
+> disallow the `Array.prototype.toSpliced` 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: `plugin:es-x/no-new-in-esnext`
+
+This rule reports ES2023 [`Array.prototype.toSpliced` methods](https://github.com/tc39/proposal-change-array-by-copy) as errors.
+
+This rule is silent by default because it's hard to know types. You need to configure [the aggressive mode](../#the-aggressive-mode) or TypeScript in order to enable this rule.
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-array-prototype-tospliced: [error, { aggressive: true }] */
+array.toSpliced(1, 1)
+```
+
+</eslint-playground>
+
+## 🔧 Options
+
+This rule has an option.
+
+```yaml
+rules:
+  es-x/no-array-prototype-tospliced: [error, { aggressive: false }]
+```
+
+### aggressive: boolean
+
+Configure the aggressive mode for only this rule.
+This is prior to the `settings['es-x'].aggressive` setting.
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-array-prototype-tospliced.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-array-prototype-tospliced.js)
diff --git a/docs/rules/no-array-prototype-with.md b/docs/rules/no-array-prototype-with.md
new file mode 100644
index 0000000..3f5629c
--- /dev/null
+++ b/docs/rules/no-array-prototype-with.md
@@ -0,0 +1,46 @@
+---
+title: "es-x/no-array-prototype-with"
+description: "disallow the `Array.prototype.with` method"
+---
+
+# es-x/no-array-prototype-with
+> disallow the `Array.prototype.with` 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: `plugin:es-x/no-new-in-esnext`
+
+This rule reports ES2023 [`Array.prototype.with` methods](https://github.com/tc39/proposal-change-array-by-copy) as errors.
+
+This rule is silent by default because it's hard to know types. You need to configure [the aggressive mode](../#the-aggressive-mode) or TypeScript in order to enable this rule.
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-array-prototype-with: [error, { aggressive: true }] */
+array.with(index, value)
+```
+
+</eslint-playground>
+
+## 🔧 Options
+
+This rule has an option.
+
+```yaml
+rules:
+  es-x/no-array-prototype-with: [error, { aggressive: false }]
+```
+
+### aggressive: boolean
+
+Configure the aggressive mode for only this rule.
+This is prior to the `settings['es-x'].aggressive` setting.
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-array-prototype-with.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-array-prototype-with.js)
diff --git a/docs/rules/no-intl-numberformat-prototype-formatrange.md b/docs/rules/no-intl-numberformat-prototype-formatrange.md
new file mode 100644
index 0000000..f5fea56
--- /dev/null
+++ b/docs/rules/no-intl-numberformat-prototype-formatrange.md
@@ -0,0 +1,51 @@
+---
+title: "es-x/no-intl-numberformat-prototype-formatrange"
+description: "disallow the `NumberFormat.prototype.formatRange` method"
+---
+
+# es-x/no-intl-numberformat-prototype-formatrange
+> disallow the `NumberFormat.prototype.formatRange` 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: `plugin:es-x/no-new-in-esnext-intl-api`
+
+This rule reports ES2023 Intl API `NumberFormat.prototype.formatRange` as errors.
+
+This rule is silent by default because it's hard to know types. You need to configure [the aggressive mode](../#the-aggressive-mode) or TypeScript in order to enable this rule.
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-intl-numberformat-prototype-formatrange: [error, { aggressive: true }] */
+const nf = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "EUR",
+  maximumFractionDigits: 0,
+});
+console.log(nf.formatRange(2.9, 3.1));
+```
+
+</eslint-playground>
+
+## 🔧 Options
+
+This rule has an option.
+
+```yml
+rules:
+  es-x/no-intl-numberformat-prototype-formatrange: [error, { aggressive: false }]
+```
+
+### aggressive: boolean
+
+Configure the aggressive mode for only this rule.
+This is prior to the `settings['es-x'].aggressive` setting.
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-intl-numberformat-prototype-formatrange.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-intl-numberformat-prototype-formatrange.js)
diff --git a/docs/rules/no-intl-numberformat-prototype-formatrangetoparts.md b/docs/rules/no-intl-numberformat-prototype-formatrangetoparts.md
new file mode 100644
index 0000000..2f37a12
--- /dev/null
+++ b/docs/rules/no-intl-numberformat-prototype-formatrangetoparts.md
@@ -0,0 +1,52 @@
+---
+title: "es-x/no-intl-numberformat-prototype-formatrangetoparts"
+description: "disallow the `NumberFormat.prototype.formatRangeToParts` method"
+---
+
+# es-x/no-intl-numberformat-prototype-formatrangetoparts
+> disallow the `NumberFormat.prototype.formatRangeToParts` 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: `plugin:es-x/no-new-in-esnext-intl-api`
+
+This rule reports ES2023 Intl API `NumberFormat.prototype.formatRangeToParts` as errors.
+
+This rule is silent by default because it's hard to know types. You need to configure [the aggressive mode](../#the-aggressive-mode) or TypeScript in order to enable this rule.
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-intl-numberformat-prototype-formatrangetoparts: [error, { aggressive: true }] */
+const nf = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "GBP",
+  currencyDisplay: "code",
+  maximumFractionDigits: 0,
+});
+nf.formatRangeToParts(3, 5);
+```
+
+</eslint-playground>
+
+## 🔧 Options
+
+This rule has an option.
+
+```yml
+rules:
+  es-x/no-intl-numberformat-prototype-formatrangetoparts: [error, { aggressive: false }]
+```
+
+### aggressive: boolean
+
+Configure the aggressive mode for only this rule.
+This is prior to the `settings['es-x'].aggressive` setting.
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-intl-numberformat-prototype-formatrangetoparts.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-intl-numberformat-prototype-formatrangetoparts.js)
diff --git a/docs/rules/no-intl-pluralrules-prototype-selectrange.md b/docs/rules/no-intl-pluralrules-prototype-selectrange.md
new file mode 100644
index 0000000..14a307e
--- /dev/null
+++ b/docs/rules/no-intl-pluralrules-prototype-selectrange.md
@@ -0,0 +1,51 @@
+---
+title: "es-x/no-intl-pluralrules-prototype-selectrange"
+description: "disallow the `PluralRules.prototype.selectRange` method"
+---
+
+# es-x/no-intl-pluralrules-prototype-selectrange
+> disallow the `PluralRules.prototype.selectRange` 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: `plugin:es-x/no-new-in-esnext-intl-api`
+
+This rule reports ES2023 Intl API `PluralRules.prototype.selectRange` as errors.
+
+This rule is silent by default because it's hard to know types. You need to configure [the aggressive mode](../#the-aggressive-mode) or TypeScript in order to enable this rule.
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-intl-pluralrules-prototype-selectrange: [error, { aggressive: true }] */
+const nf = new Intl.PluralRules("en-US", {
+  style: "currency",
+  currency: "EUR",
+  maximumFractionDigits: 0,
+});
+console.log(nf.selectRange(2.9, 3.1));
+```
+
+</eslint-playground>
+
+## 🔧 Options
+
+This rule has an option.
+
+```yml
+rules:
+  es-x/no-intl-pluralrules-prototype-selectrange: [error, { aggressive: false }]
+```
+
+### aggressive: boolean
+
+Configure the aggressive mode for only this rule.
+This is prior to the `settings['es-x'].aggressive` setting.
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-intl-pluralrules-prototype-selectrange.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-intl-pluralrules-prototype-selectrange.js)
diff --git a/lib/configs/no-new-in-esnext-intl-api.js b/lib/configs/no-new-in-esnext-intl-api.js
index f42c599..3ffd376 100644
--- a/lib/configs/no-new-in-esnext-intl-api.js
+++ b/lib/configs/no-new-in-esnext-intl-api.js
@@ -4,4 +4,11 @@
  */
 "use strict"
 
-module.exports = { plugins: ["es-x"], rules: {} }
+module.exports = {
+    plugins: ["es-x"],
+    rules: {
+        "es-x/no-intl-numberformat-prototype-formatrange": "error",
+        "es-x/no-intl-numberformat-prototype-formatrangetoparts": "error",
+        "es-x/no-intl-pluralrules-prototype-selectrange": "error",
+    },
+}
diff --git a/lib/configs/no-new-in-esnext.js b/lib/configs/no-new-in-esnext.js
index 0c2d28e..840c2f4 100644
--- a/lib/configs/no-new-in-esnext.js
+++ b/lib/configs/no-new-in-esnext.js
@@ -8,6 +8,10 @@ module.exports = {
     plugins: ["es-x"],
     rules: {
         "es-x/no-array-prototype-findlast-findlastindex": "error",
+        "es-x/no-array-prototype-toreversed": "error",
+        "es-x/no-array-prototype-tosorted": "error",
+        "es-x/no-array-prototype-tospliced": "error",
+        "es-x/no-array-prototype-with": "error",
         "es-x/no-hashbang": "error",
     },
 }
diff --git a/lib/index.js b/lib/index.js
index 76f7a37..272af65 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -93,7 +93,11 @@ module.exports = {
         "no-array-prototype-reduce": require("./rules/no-array-prototype-reduce"),
         "no-array-prototype-reduceright": require("./rules/no-array-prototype-reduceright"),
         "no-array-prototype-some": require("./rules/no-array-prototype-some"),
+        "no-array-prototype-toreversed": require("./rules/no-array-prototype-toreversed"),
+        "no-array-prototype-tosorted": require("./rules/no-array-prototype-tosorted"),
+        "no-array-prototype-tospliced": require("./rules/no-array-prototype-tospliced"),
         "no-array-prototype-values": require("./rules/no-array-prototype-values"),
+        "no-array-prototype-with": require("./rules/no-array-prototype-with"),
         "no-array-string-prototype-at": require("./rules/no-array-string-prototype-at"),
         "no-arrow-functions": require("./rules/no-arrow-functions"),
         "no-async-functions": require("./rules/no-async-functions"),
@@ -125,15 +129,18 @@ module.exports = {
         "no-hashbang": require("./rules/no-hashbang"),
         "no-import-meta": require("./rules/no-import-meta"),
         "no-initializers-in-for-in": require("./rules/no-initializers-in-for-in"),
-        "no-intl-numberformat-prototype-formattoparts": require("./rules/no-intl-numberformat-prototype-formattoparts"),
-        "no-intl-pluralrules": require("./rules/no-intl-pluralrules"),
-        "no-intl-locale": require("./rules/no-intl-locale"),
-        "no-intl-relativetimeformat": require("./rules/no-intl-relativetimeformat"),
         "no-intl-datetimeformat-prototype-formatrange": require("./rules/no-intl-datetimeformat-prototype-formatrange"),
         "no-intl-datetimeformat-prototype-formattoparts": require("./rules/no-intl-datetimeformat-prototype-formattoparts"),
         "no-intl-displaynames": require("./rules/no-intl-displaynames"),
         "no-intl-getcanonicallocales": require("./rules/no-intl-getcanonicallocales"),
         "no-intl-listformat": require("./rules/no-intl-listformat"),
+        "no-intl-locale": require("./rules/no-intl-locale"),
+        "no-intl-numberformat-prototype-formatrange": require("./rules/no-intl-numberformat-prototype-formatrange"),
+        "no-intl-numberformat-prototype-formatrangetoparts": require("./rules/no-intl-numberformat-prototype-formatrangetoparts"),
+        "no-intl-numberformat-prototype-formattoparts": require("./rules/no-intl-numberformat-prototype-formattoparts"),
+        "no-intl-pluralrules": require("./rules/no-intl-pluralrules"),
+        "no-intl-pluralrules-prototype-selectrange": require("./rules/no-intl-pluralrules-prototype-selectrange"),
+        "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-json": require("./rules/no-json"),
diff --git a/lib/rules/no-array-prototype-toreversed.js b/lib/rules/no-array-prototype-toreversed.js
new file mode 100644
index 0000000..74b02f2
--- /dev/null
+++ b/lib/rules/no-array-prototype-toreversed.js
@@ -0,0 +1,46 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Array.prototype.toReversed` method.",
+            category: "ES2023",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-toreversed.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2023 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Array: ["toReversed"],
+            Int8Array: ["toReversed"],
+            Uint8Array: ["toReversed"],
+            Uint8ClampedArray: ["toReversed"],
+            Int16Array: ["toReversed"],
+            Uint16Array: ["toReversed"],
+            Int32Array: ["toReversed"],
+            Uint32Array: ["toReversed"],
+            Float32Array: ["toReversed"],
+            Float64Array: ["toReversed"],
+            BigInt64Array: ["toReversed"],
+            BigUint64Array: ["toReversed"],
+        })
+    },
+}
diff --git a/lib/rules/no-array-prototype-tosorted.js b/lib/rules/no-array-prototype-tosorted.js
new file mode 100644
index 0000000..af65c18
--- /dev/null
+++ b/lib/rules/no-array-prototype-tosorted.js
@@ -0,0 +1,46 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Array.prototype.toSorted` method.",
+            category: "ES2023",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-tosorted.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2023 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Array: ["toSorted"],
+            Int8Array: ["toSorted"],
+            Uint8Array: ["toSorted"],
+            Uint8ClampedArray: ["toSorted"],
+            Int16Array: ["toSorted"],
+            Uint16Array: ["toSorted"],
+            Int32Array: ["toSorted"],
+            Uint32Array: ["toSorted"],
+            Float32Array: ["toSorted"],
+            Float64Array: ["toSorted"],
+            BigInt64Array: ["toSorted"],
+            BigUint64Array: ["toSorted"],
+        })
+    },
+}
diff --git a/lib/rules/no-array-prototype-tospliced.js b/lib/rules/no-array-prototype-tospliced.js
new file mode 100644
index 0000000..cee1721
--- /dev/null
+++ b/lib/rules/no-array-prototype-tospliced.js
@@ -0,0 +1,35 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Array.prototype.toSpliced` method.",
+            category: "ES2023",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-tospliced.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2023 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Array: ["toSpliced"],
+        })
+    },
+}
diff --git a/lib/rules/no-array-prototype-with.js b/lib/rules/no-array-prototype-with.js
new file mode 100644
index 0000000..266c1cc
--- /dev/null
+++ b/lib/rules/no-array-prototype-with.js
@@ -0,0 +1,46 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow the `Array.prototype.with` method.",
+            category: "ES2023",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-with.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2023 '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            Array: ["with"],
+            Int8Array: ["with"],
+            Uint8Array: ["with"],
+            Uint8ClampedArray: ["with"],
+            Int16Array: ["with"],
+            Uint16Array: ["with"],
+            Int32Array: ["with"],
+            Uint32Array: ["with"],
+            Float32Array: ["with"],
+            Float64Array: ["with"],
+            BigInt64Array: ["with"],
+            BigUint64Array: ["with"],
+        })
+    },
+}
diff --git a/lib/rules/no-intl-numberformat-prototype-formatrange.js b/lib/rules/no-intl-numberformat-prototype-formatrange.js
new file mode 100644
index 0000000..888a400
--- /dev/null
+++ b/lib/rules/no-intl-numberformat-prototype-formatrange.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description:
+                "disallow the `NumberFormat.prototype.formatRange` method.",
+            category: "ES2023-Intl-API",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-intl-numberformat-prototype-formatrange.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2023 Intl API '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            "Intl.NumberFormat": ["formatRange"],
+        })
+    },
+}
diff --git a/lib/rules/no-intl-numberformat-prototype-formatrangetoparts.js b/lib/rules/no-intl-numberformat-prototype-formatrangetoparts.js
new file mode 100644
index 0000000..ac489b2
--- /dev/null
+++ b/lib/rules/no-intl-numberformat-prototype-formatrangetoparts.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description:
+                "disallow the `NumberFormat.prototype.formatRangeToParts` method.",
+            category: "ES2023-Intl-API",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-intl-numberformat-prototype-formatrangetoparts.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2023 Intl API '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            "Intl.NumberFormat": ["formatRangeToParts"],
+        })
+    },
+}
diff --git a/lib/rules/no-intl-pluralrules-prototype-selectrange.js b/lib/rules/no-intl-pluralrules-prototype-selectrange.js
new file mode 100644
index 0000000..8e15b7d
--- /dev/null
+++ b/lib/rules/no-intl-pluralrules-prototype-selectrange.js
@@ -0,0 +1,36 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description:
+                "disallow the `PluralRules.prototype.selectRange` method.",
+            category: "ES2023-Intl-API",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-intl-pluralrules-prototype-selectrange.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2023 Intl API '{{name}}' method is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(context, {
+            "Intl.PluralRules": ["selectRange"],
+        })
+    },
+}


Test patch:
diff --git a/tests/lib/rules/no-array-prototype-toreversed.js b/tests/lib/rules/no-array-prototype-toreversed.js
new file mode 100644
index 0000000..112a38e
--- /dev/null
+++ b/tests/lib/rules/no-array-prototype-toreversed.js
@@ -0,0 +1,213 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-array-prototype-toreversed.js")
+const ruleId = "no-array-prototype-toreversed"
+
+new RuleTester().run(ruleId, rule, {
+    valid: [
+        "toReversed()",
+        "foo.find(predicate)",
+        "foo.toReversed()",
+        {
+            code: "toReversed()",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.find(predicate)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.toReversed()",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            code: "['foo'].toReversed()",
+            errors: [
+                "ES2023 'Array.prototype.toReversed' method is forbidden.",
+            ],
+        },
+        {
+            code: "foo.toReversed()",
+            errors: [
+                "ES2023 'Array.prototype.toReversed' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.toReversed()",
+            options: [{ aggressive: true }],
+            errors: [
+                "ES2023 'Array.prototype.toReversed' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: false } },
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require.resolve("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({ parser }).run(`${ruleId} TS`, rule, {
+    valid: [
+        { filename, code: "toReversed()" },
+        { filename, code: "foo.find(predicate)" },
+        { filename, code: "foo.toReversed()" },
+        { filename, code: "let foo = {}; foo.toReversed()" },
+        {
+            filename,
+            code: "toReversed()",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.find(predicate)",
+            settings: { "es-x": { aggressive: true } },
+        },
+
+        // `Array` is unknown type if tsconfig.json is not configured.
+        { filename, code: "let foo = []; foo.toReversed()" },
+        {
+            filename,
+            code: "let foo = ['foo']; foo.toReversed()",
+            errors: [
+                "ES2023 'Array.prototype.toReversed' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "function f<T extends string[]>(a: T) { a.toReversed() }",
+            errors: [
+                "ES2023 'Array.prototype.toReversed' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "function f<T extends (string | number)[]>(a: T) { a.toReversed() }",
+            errors: [
+                "ES2023 'Array.prototype.toReversed' method is forbidden.",
+            ],
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "['foo'].toReversed()",
+            errors: [
+                "ES2023 'Array.prototype.toReversed' method is forbidden.",
+            ],
+        },
+        {
+            filename,
+            code: "let foo = []; foo.toReversed()",
+            errors: [
+                "ES2023 'Array.prototype.toReversed' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.toReversed()",
+            errors: [
+                "ES2023 'Array.prototype.toReversed' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
+
+new RuleTester({ parser, parserOptions: { tsconfigRootDir, project } }).run(
+    `${ruleId} TS Full Type Information`,
+    rule,
+    {
+        valid: [
+            { filename, code: "toReversed()" },
+            { filename, code: "foo.find(predicate)" },
+            { filename, code: "foo.toReversed()" },
+            { filename, code: "let foo = {}; foo.toReversed()" },
+            {
+                filename,
+                code: "toReversed()",
+                settings: { "es-x": { aggressive: true } },
+            },
+            {
+                filename,
+                code: "foo.find(predicate)",
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+        invalid: [
+            {
+                filename,
+                code: "['foo'].toReversed()",
+                errors: [
+                    "ES2023 'Array.prototype.toReversed' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "let foo = ['foo']; foo.toReversed()",
+                errors: [
+                    "ES2023 'Array.prototype.toReversed' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "let foo = []; foo.toReversed()",
+                errors: [
+                    "ES2023 'Array.prototype.toReversed' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "function f<T extends string[]>(a: T) { a.toReversed() }",
+                errors: [
+                    "ES2023 'Array.prototype.toReversed' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "function f<T extends (string | number)[]>(a: T) { a.toReversed() }",
+                errors: [
+                    "ES2023 'Array.prototype.toReversed' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "foo.toReversed()",
+                errors: [
+                    "ES2023 'Array.prototype.toReversed' method is forbidden.",
+                ],
+                settings: { "es-x": { aggressive: true } },
+            },
+            ...[
+                "Int8Array",
+                "Uint8Array",
+                "Uint8ClampedArray",
+                "Int16Array",
+                "Uint16Array",
+                "Int32Array",
+                "Uint32Array",
+                "Float32Array",
+                "Float64Array",
+                "BigInt64Array",
+                "BigUint64Array",
+            ].map((className) => ({
+                filename,
+                code: `let foo = new ${className}(10); foo.toReversed()`,
+                errors: [
+                    `ES2023 '${className}.prototype.toReversed' method is forbidden.`,
+                ],
+            })),
+        ],
+    },
+)
diff --git a/tests/lib/rules/no-array-prototype-tosorted.js b/tests/lib/rules/no-array-prototype-tosorted.js
new file mode 100644
index 0000000..f1200a4
--- /dev/null
+++ b/tests/lib/rules/no-array-prototype-tosorted.js
@@ -0,0 +1,195 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-array-prototype-tosorted.js")
+const ruleId = "no-array-prototype-tosorted"
+
+new RuleTester().run(ruleId, rule, {
+    valid: [
+        "toSorted()",
+        "foo.find(predicate)",
+        "foo.toSorted()",
+        {
+            code: "toSorted()",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.find(predicate)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.toSorted()",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            code: "['foo'].toSorted()",
+            errors: ["ES2023 'Array.prototype.toSorted' method is forbidden."],
+        },
+        {
+            code: "foo.toSorted()",
+            errors: ["ES2023 'Array.prototype.toSorted' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.toSorted()",
+            options: [{ aggressive: true }],
+            errors: ["ES2023 'Array.prototype.toSorted' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require.resolve("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({ parser }).run(`${ruleId} TS`, rule, {
+    valid: [
+        { filename, code: "toSorted()" },
+        { filename, code: "foo.find(predicate)" },
+        { filename, code: "foo.toSorted()" },
+        { filename, code: "let foo = {}; foo.toSorted()" },
+        {
+            filename,
+            code: "toSorted()",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.find(predicate)",
+            settings: { "es-x": { aggressive: true } },
+        },
+
+        // `Array` is unknown type if tsconfig.json is not configured.
+        { filename, code: "let foo = []; foo.toSorted()" },
+        {
+            filename,
+            code: "let foo = ['foo']; foo.toSorted()",
+            errors: ["ES2023 'Array.prototype.toSorted' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f<T extends string[]>(a: T) { a.toSorted() }",
+            errors: ["ES2023 'Array.prototype.toSorted' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f<T extends (string | number)[]>(a: T) { a.toSorted() }",
+            errors: ["ES2023 'Array.prototype.toSorted' method is forbidden."],
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "['foo'].toSorted()",
+            errors: ["ES2023 'Array.prototype.toSorted' method is forbidden."],
+        },
+        {
+            filename,
+            code: "let foo = []; foo.toSorted()",
+            errors: ["ES2023 'Array.prototype.toSorted' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.toSorted()",
+            errors: ["ES2023 'Array.prototype.toSorted' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
+
+new RuleTester({ parser, parserOptions: { tsconfigRootDir, project } }).run(
+    `${ruleId} TS Full Type Information`,
+    rule,
+    {
+        valid: [
+            { filename, code: "toSorted()" },
+            { filename, code: "foo.find(predicate)" },
+            { filename, code: "foo.toSorted()" },
+            { filename, code: "let foo = {}; foo.toSorted()" },
+            {
+                filename,
+                code: "toSorted()",
+                settings: { "es-x": { aggressive: true } },
+            },
+            {
+                filename,
+                code: "foo.find(predicate)",
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+        invalid: [
+            {
+                filename,
+                code: "['foo'].toSorted()",
+                errors: [
+                    "ES2023 'Array.prototype.toSorted' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "let foo = ['foo']; foo.toSorted()",
+                errors: [
+                    "ES2023 'Array.prototype.toSorted' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "let foo = []; foo.toSorted()",
+                errors: [
+                    "ES2023 'Array.prototype.toSorted' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "function f<T extends string[]>(a: T) { a.toSorted() }",
+                errors: [
+                    "ES2023 'Array.prototype.toSorted' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "function f<T extends (string | number)[]>(a: T) { a.toSorted() }",
+                errors: [
+                    "ES2023 'Array.prototype.toSorted' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "foo.toSorted()",
+                errors: [
+                    "ES2023 'Array.prototype.toSorted' method is forbidden.",
+                ],
+                settings: { "es-x": { aggressive: true } },
+            },
+            ...[
+                "Int8Array",
+                "Uint8Array",
+                "Uint8ClampedArray",
+                "Int16Array",
+                "Uint16Array",
+                "Int32Array",
+                "Uint32Array",
+                "Float32Array",
+                "Float64Array",
+                "BigInt64Array",
+                "BigUint64Array",
+            ].map((className) => ({
+                filename,
+                code: `let foo = new ${className}(10); foo.toSorted()`,
+                errors: [
+                    `ES2023 '${className}.prototype.toSorted' method is forbidden.`,
+                ],
+            })),
+        ],
+    },
+)
diff --git a/tests/lib/rules/no-array-prototype-tospliced.js b/tests/lib/rules/no-array-prototype-tospliced.js
new file mode 100644
index 0000000..c4a5bab
--- /dev/null
+++ b/tests/lib/rules/no-array-prototype-tospliced.js
@@ -0,0 +1,176 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-array-prototype-tospliced.js")
+const ruleId = "no-array-prototype-tospliced"
+
+new RuleTester().run(ruleId, rule, {
+    valid: [
+        "toSpliced(1, 2)",
+        "foo.find(predicate)",
+        "foo.toSpliced(1, 2)",
+        {
+            code: "toSpliced(1, 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.find(predicate)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.toSpliced(1, 2)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            code: "['foo'].toSpliced(1, 2)",
+            errors: ["ES2023 'Array.prototype.toSpliced' method is forbidden."],
+        },
+        {
+            code: "foo.toSpliced(1, 2)",
+            errors: ["ES2023 'Array.prototype.toSpliced' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.toSpliced(1, 2)",
+            options: [{ aggressive: true }],
+            errors: ["ES2023 'Array.prototype.toSpliced' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require.resolve("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({ parser }).run(`${ruleId} TS`, rule, {
+    valid: [
+        { filename, code: "toSpliced(1, 2)" },
+        { filename, code: "foo.find(predicate)" },
+        { filename, code: "foo.toSpliced(1, 2)" },
+        { filename, code: "let foo = {}; foo.toSpliced(1, 2)" },
+        {
+            filename,
+            code: "toSpliced(1, 2)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.find(predicate)",
+            settings: { "es-x": { aggressive: true } },
+        },
+
+        // `Array` is unknown type if tsconfig.json is not configured.
+        { filename, code: "let foo = []; foo.toSpliced(1, 2)" },
+        {
+            filename,
+            code: "let foo = ['foo']; foo.toSpliced(1, 2)",
+            errors: ["ES2023 'Array.prototype.toSpliced' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f<T extends string[]>(a: T) { a.toSpliced(1, 2) }",
+            errors: ["ES2023 'Array.prototype.toSpliced' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f<T extends (string | number)[]>(a: T) { a.toSpliced(1, 2) }",
+            errors: ["ES2023 'Array.prototype.toSpliced' method is forbidden."],
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "['foo'].toSpliced(1, 2)",
+            errors: ["ES2023 'Array.prototype.toSpliced' method is forbidden."],
+        },
+        {
+            filename,
+            code: "let foo = []; foo.toSpliced(1, 2)",
+            errors: ["ES2023 'Array.prototype.toSpliced' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.toSpliced(1, 2)",
+            errors: ["ES2023 'Array.prototype.toSpliced' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
+
+new RuleTester({ parser, parserOptions: { tsconfigRootDir, project } }).run(
+    `${ruleId} TS Full Type Information`,
+    rule,
+    {
+        valid: [
+            { filename, code: "toSpliced(1, 2)" },
+            { filename, code: "foo.find(predicate)" },
+            { filename, code: "foo.toSpliced(1, 2)" },
+            { filename, code: "let foo = {}; foo.toSpliced(1, 2)" },
+            {
+                filename,
+                code: "toSpliced(1, 2)",
+                settings: { "es-x": { aggressive: true } },
+            },
+            {
+                filename,
+                code: "foo.find(predicate)",
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+        invalid: [
+            {
+                filename,
+                code: "['foo'].toSpliced(1, 2)",
+                errors: [
+                    "ES2023 'Array.prototype.toSpliced' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "let foo = ['foo']; foo.toSpliced(1, 2)",
+                errors: [
+                    "ES2023 'Array.prototype.toSpliced' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "let foo = []; foo.toSpliced(1, 2)",
+                errors: [
+                    "ES2023 'Array.prototype.toSpliced' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "function f<T extends string[]>(a: T) { a.toSpliced(1, 2) }",
+                errors: [
+                    "ES2023 'Array.prototype.toSpliced' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "function f<T extends (string | number)[]>(a: T) { a.toSpliced(1, 2) }",
+                errors: [
+                    "ES2023 'Array.prototype.toSpliced' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "foo.toSpliced(1, 2)",
+                errors: [
+                    "ES2023 'Array.prototype.toSpliced' method is forbidden.",
+                ],
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+    },
+)
diff --git a/tests/lib/rules/no-array-prototype-with.js b/tests/lib/rules/no-array-prototype-with.js
new file mode 100644
index 0000000..9f8e4c2
--- /dev/null
+++ b/tests/lib/rules/no-array-prototype-with.js
@@ -0,0 +1,166 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-array-prototype-with.js")
+const ruleId = "no-array-prototype-with"
+
+new RuleTester().run(ruleId, rule, {
+    valid: [
+        "foo.find(predicate)",
+        "foo.with(index, value)",
+        {
+            code: "foo.find(predicate)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.with(index, value)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            code: "['foo'].with(index, value)",
+            errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+        },
+        {
+            code: "foo.with(index, value)",
+            errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.with(index, value)",
+            options: [{ aggressive: true }],
+            errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+            settings: { "es-x": { aggressive: false } },
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require.resolve("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({ parser }).run(`${ruleId} TS`, rule, {
+    valid: [
+        { filename, code: "foo.find(predicate)" },
+        { filename, code: "foo.with(index, value)" },
+        { filename, code: "let foo = {}; foo.with(index, value)" },
+        {
+            filename,
+            code: "foo.find(predicate)",
+            settings: { "es-x": { aggressive: true } },
+        },
+
+        // `Array` is unknown type if tsconfig.json is not configured.
+        { filename, code: "let foo = []; foo.with(index, value)" },
+        {
+            filename,
+            code: "let foo = ['foo']; foo.with(index, value)",
+            errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f<T extends string[]>(a: T) { a.with(index, value) }",
+            errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+        },
+        {
+            filename,
+            code: "function f<T extends (string | number)[]>(a: T) { a.with(index, value) }",
+            errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "['foo'].with(index, value)",
+            errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+        },
+        {
+            filename,
+            code: "let foo = []; foo.with(index, value)",
+            errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.with(index, value)",
+            errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
+
+new RuleTester({ parser, parserOptions: { tsconfigRootDir, project } }).run(
+    `${ruleId} TS Full Type Information`,
+    rule,
+    {
+        valid: [
+            { filename, code: "foo.find(predicate)" },
+            { filename, code: "foo.with(index, value)" },
+            { filename, code: "let foo = {}; foo.with(index, value)" },
+            {
+                filename,
+                code: "foo.find(predicate)",
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+        invalid: [
+            {
+                filename,
+                code: "['foo'].with(index, value)",
+                errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+            },
+            {
+                filename,
+                code: "let foo = ['foo']; foo.with(index, value)",
+                errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+            },
+            {
+                filename,
+                code: "let foo = []; foo.with(index, value)",
+                errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+            },
+            {
+                filename,
+                code: "function f<T extends string[]>(a: T) { a.with(index, value) }",
+                errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+            },
+            {
+                filename,
+                code: "function f<T extends (string | number)[]>(a: T) { a.with(index, value) }",
+                errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+            },
+            {
+                filename,
+                code: "foo.with(index, value)",
+                errors: ["ES2023 'Array.prototype.with' method is forbidden."],
+                settings: { "es-x": { aggressive: true } },
+            },
+            ...[
+                "Int8Array",
+                "Uint8Array",
+                "Uint8ClampedArray",
+                "Int16Array",
+                "Uint16Array",
+                "Int32Array",
+                "Uint32Array",
+                "Float32Array",
+                "Float64Array",
+                "BigInt64Array",
+                "BigUint64Array",
+            ].map((className) => ({
+                filename,
+                code: `let foo = new ${className}(10); foo.with(index, value)`,
+                errors: [
+                    `ES2023 '${className}.prototype.with' method is forbidden.`,
+                ],
+            })),
+        ],
+    },
+)
diff --git a/tests/lib/rules/no-intl-numberformat-prototype-formatrange.js b/tests/lib/rules/no-intl-numberformat-prototype-formatrange.js
new file mode 100644
index 0000000..d31ad62
--- /dev/null
+++ b/tests/lib/rules/no-intl-numberformat-prototype-formatrange.js
@@ -0,0 +1,136 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-intl-numberformat-prototype-formatrange.js")
+const ruleId = "no-intl-numberformat-prototype-formatrange"
+
+new RuleTester().run(ruleId, rule, {
+    valid: [
+        "formatRange(2.9, 3.1)",
+        "foo.unknown(0)",
+        "foo.formatRange(2.9, 3.1)",
+        {
+            code: "formatRange(2.9, 3.1)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.formatRange(2.9, 3.1)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            code: "foo.formatRange(2.9, 3.1)",
+            errors: [
+                "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRange' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.formatRange(2.9, 3.1)",
+            options: [{ aggressive: true }],
+            errors: [
+                "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRange' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: false } },
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require.resolve("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({ parser }).run(`${ruleId} TS`, rule, {
+    valid: [
+        { filename, code: "formatRange(2.9, 3.1)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.formatRange(2.9, 3.1)" },
+        { filename, code: "let foo = {}; foo.formatRange(2.9, 3.1)" },
+        {
+            filename,
+            code: "formatRange(2.9, 3.1)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = new Unknown(); foo.formatRange(2.9, 3.1)",
+            errors: [
+                "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRange' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.formatRange(2.9, 3.1)",
+            errors: [
+                "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRange' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
+
+new RuleTester({ parser, parserOptions: { tsconfigRootDir, project } }).run(
+    `${ruleId} TS Full Type Information`,
+    rule,
+    {
+        valid: [
+            { filename, code: "formatRange(2.9, 3.1)" },
+            { filename, code: "foo.unknown(0)" },
+            { filename, code: "foo.formatRange(2.9, 3.1)" },
+            {
+                filename,
+                code: "let foo = {}; foo.formatRange(2.9, 3.1)",
+            },
+            {
+                filename,
+                code: "formatRange(2.9, 3.1)",
+                settings: { "es-x": { aggressive: true } },
+            },
+            {
+                filename,
+                code: "foo.unknown(0)",
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+        invalid: [
+            {
+                filename,
+                code: "let foo = new Intl.NumberFormat(); foo.formatRange(2.9, 3.1)",
+                errors: [
+                    "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRange' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "function f(a: Intl.NumberFormat) { a.formatRange(2.9, 3.1) }",
+                errors: [
+                    "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRange' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "foo.formatRange(2.9, 3.1)",
+                errors: [
+                    "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRange' method is forbidden.",
+                ],
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+    },
+)
diff --git a/tests/lib/rules/no-intl-numberformat-prototype-formatrangetoparts.js b/tests/lib/rules/no-intl-numberformat-prototype-formatrangetoparts.js
new file mode 100644
index 0000000..249aa85
--- /dev/null
+++ b/tests/lib/rules/no-intl-numberformat-prototype-formatrangetoparts.js
@@ -0,0 +1,136 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-intl-numberformat-prototype-formatrangetoparts.js")
+const ruleId = "no-intl-numberformat-prototype-formatrangetoparts"
+
+new RuleTester().run(ruleId, rule, {
+    valid: [
+        "formatRangeToParts(2.9, 3.1)",
+        "foo.unknown(0)",
+        "foo.formatRangeToParts(2.9, 3.1)",
+        {
+            code: "formatRangeToParts(2.9, 3.1)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.formatRangeToParts(2.9, 3.1)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            code: "foo.formatRangeToParts(2.9, 3.1)",
+            errors: [
+                "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRangeToParts' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.formatRangeToParts(2.9, 3.1)",
+            options: [{ aggressive: true }],
+            errors: [
+                "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRangeToParts' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: false } },
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require.resolve("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({ parser }).run(`${ruleId} TS`, rule, {
+    valid: [
+        { filename, code: "formatRangeToParts(2.9, 3.1)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.formatRangeToParts(2.9, 3.1)" },
+        { filename, code: "let foo = {}; foo.formatRangeToParts(2.9, 3.1)" },
+        {
+            filename,
+            code: "formatRangeToParts(2.9, 3.1)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = new Unknown(); foo.formatRangeToParts(2.9, 3.1)",
+            errors: [
+                "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRangeToParts' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.formatRangeToParts(2.9, 3.1)",
+            errors: [
+                "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRangeToParts' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
+
+new RuleTester({ parser, parserOptions: { tsconfigRootDir, project } }).run(
+    `${ruleId} TS Full Type Information`,
+    rule,
+    {
+        valid: [
+            { filename, code: "formatRangeToParts(2.9, 3.1)" },
+            { filename, code: "foo.unknown(0)" },
+            { filename, code: "foo.formatRangeToParts(2.9, 3.1)" },
+            {
+                filename,
+                code: "let foo = {}; foo.formatRangeToParts(2.9, 3.1)",
+            },
+            {
+                filename,
+                code: "formatRangeToParts(2.9, 3.1)",
+                settings: { "es-x": { aggressive: true } },
+            },
+            {
+                filename,
+                code: "foo.unknown(0)",
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+        invalid: [
+            {
+                filename,
+                code: "let foo = new Intl.NumberFormat(); foo.formatRangeToParts(2.9, 3.1)",
+                errors: [
+                    "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRangeToParts' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "function f(a: Intl.NumberFormat) { a.formatRangeToParts(2.9, 3.1) }",
+                errors: [
+                    "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRangeToParts' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "foo.formatRangeToParts(2.9, 3.1)",
+                errors: [
+                    "ES2023 Intl API 'Intl.NumberFormat.prototype.formatRangeToParts' method is forbidden.",
+                ],
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+    },
+)
diff --git a/tests/lib/rules/no-intl-pluralrules-prototype-selectrange.js b/tests/lib/rules/no-intl-pluralrules-prototype-selectrange.js
new file mode 100644
index 0000000..822a2f8
--- /dev/null
+++ b/tests/lib/rules/no-intl-pluralrules-prototype-selectrange.js
@@ -0,0 +1,136 @@
+"use strict"
+
+const path = require("path")
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-intl-pluralrules-prototype-selectrange.js")
+const ruleId = "no-intl-pluralrules-prototype-selectrange"
+
+new RuleTester().run(ruleId, rule, {
+    valid: [
+        "selectRange(2.9, 3.1)",
+        "foo.unknown(0)",
+        "foo.selectRange(2.9, 3.1)",
+        {
+            code: "selectRange(2.9, 3.1)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        { code: "foo.unknown(0)", settings: { "es-x": { aggressive: true } } },
+        {
+            code: "foo.selectRange(2.9, 3.1)",
+            options: [{ aggressive: false }],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            code: "foo.selectRange(2.9, 3.1)",
+            errors: [
+                "ES2023 Intl API 'Intl.PluralRules.prototype.selectRange' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            code: "foo.selectRange(2.9, 3.1)",
+            options: [{ aggressive: true }],
+            errors: [
+                "ES2023 Intl API 'Intl.PluralRules.prototype.selectRange' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: false } },
+        },
+    ],
+})
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+const parser = require.resolve("@typescript-eslint/parser")
+const tsconfigRootDir = path.resolve(__dirname, "../../fixtures")
+const project = "tsconfig.json"
+const filename = path.join(tsconfigRootDir, "test.ts")
+
+new RuleTester({ parser }).run(`${ruleId} TS`, rule, {
+    valid: [
+        { filename, code: "selectRange(2.9, 3.1)" },
+        { filename, code: "foo.unknown(0)" },
+        { filename, code: "foo.selectRange(2.9, 3.1)" },
+        { filename, code: "let foo = {}; foo.selectRange(2.9, 3.1)" },
+        {
+            filename,
+            code: "selectRange(2.9, 3.1)",
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.unknown(0)",
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+    invalid: [
+        {
+            filename,
+            code: "let foo = new Unknown(); foo.selectRange(2.9, 3.1)",
+            errors: [
+                "ES2023 Intl API 'Intl.PluralRules.prototype.selectRange' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+        {
+            filename,
+            code: "foo.selectRange(2.9, 3.1)",
+            errors: [
+                "ES2023 Intl API 'Intl.PluralRules.prototype.selectRange' method is forbidden.",
+            ],
+            settings: { "es-x": { aggressive: true } },
+        },
+    ],
+})
+
+new RuleTester({ parser, parserOptions: { tsconfigRootDir, project } }).run(
+    `${ruleId} TS Full Type Information`,
+    rule,
+    {
+        valid: [
+            { filename, code: "selectRange(2.9, 3.1)" },
+            { filename, code: "foo.unknown(0)" },
+            { filename, code: "foo.selectRange(2.9, 3.1)" },
+            {
+                filename,
+                code: "let foo = {}; foo.selectRange(2.9, 3.1)",
+            },
+            {
+                filename,
+                code: "selectRange(2.9, 3.1)",
+                settings: { "es-x": { aggressive: true } },
+            },
+            {
+                filename,
+                code: "foo.unknown(0)",
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+        invalid: [
+            {
+                filename,
+                code: "let foo = new Intl.PluralRules(); foo.selectRange(2.9, 3.1)",
+                errors: [
+                    "ES2023 Intl API 'Intl.PluralRules.prototype.selectRange' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "function f(a: Intl.PluralRules) { a.selectRange(2.9, 3.1) }",
+                errors: [
+                    "ES2023 Intl API 'Intl.PluralRules.prototype.selectRange' method is forbidden.",
+                ],
+            },
+            {
+                filename,
+                code: "foo.selectRange(2.9, 3.1)",
+                errors: [
+                    "ES2023 Intl API 'Intl.PluralRules.prototype.selectRange' method is forbidden.",
+                ],
+                settings: { "es-x": { aggressive: true } },
+            },
+        ],
+    },
+)