Update checked-in dependencies

node_modules/.package-lock.json

@@ -838,15 +838,19 @@
       }
     },
     "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.4.0",
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz",
+      "integrity": "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
-        "eslint-visitor-keys": "^3.3.0"
+        "eslint-visitor-keys": "^3.4.3"
       },
       "engines": {
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
       },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
       "peerDependencies": {
         "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
       }
@@ -933,9 +937,9 @@
       }
     },
     "node_modules/@eslint/js": {
-      "version": "9.25.1",
+      "version": "9.26.0",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.25.1.tgz",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.26.0.tgz",
-      "integrity": "sha512-dEIwmjntEx8u3Uvv+kr3PDeeArL8Hw07H9kyYxCjnM9pBjfEhk6uLXSchxxzgiwtRhhzVzqmUSDFBOi1TuZ7qg==",
+      "integrity": "sha512-I9XlJawFdSMvWjDt6wksMCrgns5ggLNfFwFvnShsleWruvXM514Qxk8V246efTw+eo9JABvVz+u3q2RiAowKxQ==",
       "dev": true,
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2005,20 +2009,20 @@
       "license": "MIT"
     },
     "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.32.1.tgz",
-      "integrity": "sha512-oUlH4h1ABavI4F0Xnl8/fOtML/eu8nI2A1nYd+f+55XI0BLu+RIqKoCiZKNo6DtqZBEQm5aNKA20G3Z5w3R6GQ==",
+      "integrity": "sha512-6u6Plg9nP/J1GRpe/vcjjabo6Uc5YQPAMxsgQyGC/I0RuukiG1wIe3+Vtg3IrSCVJDmqK3j8adrtzXSENRtFgg==",
       "dev": true,
       "dependencies": {
         "@eslint-community/regexpp": "^4.10.0",
-        "@typescript-eslint/scope-manager": "8.31.1",
+        "@typescript-eslint/scope-manager": "8.32.1",
-        "@typescript-eslint/type-utils": "8.31.1",
+        "@typescript-eslint/type-utils": "8.32.1",
-        "@typescript-eslint/utils": "8.31.1",
+        "@typescript-eslint/utils": "8.32.1",
-        "@typescript-eslint/visitor-keys": "8.31.1",
+        "@typescript-eslint/visitor-keys": "8.32.1",
         "graphemer": "^1.4.0",
-        "ignore": "^5.3.1",
+        "ignore": "^7.0.0",
         "natural-compare": "^1.4.0",
-        "ts-api-utils": "^2.0.1"
+        "ts-api-utils": "^2.1.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2034,13 +2038,13 @@
       }
     },
     "node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.32.1.tgz",
-      "integrity": "sha512-BMNLOElPxrtNQMIsFHE+3P0Yf1z0dJqV9zLdDxN/xLlWMlXK/ApEsVEKzpizg9oal8bAT5Sc7+ocal7AC1HCVw==",
+      "integrity": "sha512-7IsIaIDeZn7kffk7qXC3o6Z4UblZJKV3UBpkvRNpr5NSyLji7tvTcvmnMNYuYLyh26mN8W723xpo3i4MlD33vA==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
-        "@typescript-eslint/visitor-keys": "8.31.1"
+        "@typescript-eslint/visitor-keys": "8.32.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2051,9 +2055,9 @@
       }
     },
     "node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/types": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.32.1.tgz",
-      "integrity": "sha512-SfepaEFUDQYRoA70DD9GtytljBePSj17qPxFHA/h3eg6lPTqGJ5mWOtbXCk1YrVU1cTJRd14nhaXWFu0l2troQ==",
+      "integrity": "sha512-YmybwXUJcgGqgAp6bEsgpPXEg6dcCyPyCSr0CAAueacR/CCBi25G3V8gGQ2kRzQRBNol7VQknxMs9HvVa9Rvfg==",
       "dev": true,
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2064,19 +2068,19 @@
       }
     },
     "node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.32.1.tgz",
-      "integrity": "sha512-kaA0ueLe2v7KunYOyWYtlf/QhhZb7+qh4Yw6Ni5kgukMIG+iP773tjgBiLWIXYumWCwEq3nLW+TUywEp8uEeag==",
+      "integrity": "sha512-Y3AP9EIfYwBb4kWGb+simvPaqQoT5oJuzzj9m0i6FCY6SPvlomY2Ei4UEMm7+FXtlNJbor80ximyslzaQF6xhg==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
-        "@typescript-eslint/visitor-keys": "8.31.1",
+        "@typescript-eslint/visitor-keys": "8.32.1",
         "debug": "^4.3.4",
         "fast-glob": "^3.3.2",
         "is-glob": "^4.0.3",
         "minimatch": "^9.0.4",
         "semver": "^7.6.0",
-        "ts-api-utils": "^2.0.1"
+        "ts-api-utils": "^2.1.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2090,15 +2094,15 @@
       }
     },
     "node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/utils": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.32.1.tgz",
-      "integrity": "sha512-2DSI4SNfF5T4oRveQ4nUrSjUqjMND0nLq9rEkz0gfGr3tg0S5KB6DhwR+WZPCjzkZl3cH+4x2ce3EsL50FubjQ==",
+      "integrity": "sha512-DsSFNIgLSrc89gpq1LJB7Hm1YpuhK086DRDJSNrewcGvYloWW1vZLHBTIvarKZDcAORIy/uWNx8Gad+4oMpkSA==",
       "dev": true,
       "dependencies": {
-        "@eslint-community/eslint-utils": "^4.4.0",
+        "@eslint-community/eslint-utils": "^4.7.0",
-        "@typescript-eslint/scope-manager": "8.31.1",
+        "@typescript-eslint/scope-manager": "8.32.1",
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
-        "@typescript-eslint/typescript-estree": "8.31.1"
+        "@typescript-eslint/typescript-estree": "8.32.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2113,12 +2117,12 @@
       }
     },
     "node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.32.1.tgz",
-      "integrity": "sha512-I+/rgqOVBn6f0o7NDTmAPWWC6NuqhV174lfYvAm9fUaWeiefLdux9/YI3/nLugEn9L8fcSi0XmpKi/r5u0nmpw==",
+      "integrity": "sha512-ar0tjQfObzhSaW3C3QNmTc5ofj0hDoNQ5XWrCy6zDyabdr0TWhCkClp+rywGNj/odAFBVzzJrK4tEq5M4Hmu4w==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
         "eslint-visitor-keys": "^4.2.0"
       },
       "engines": {
@@ -2150,6 +2154,15 @@
         "url": "https://opencollective.com/eslint"
       }
     },
+    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.4.tgz",
+      "integrity": "sha512-gJzzk+PQNznz8ysRrC0aOkBNVRBDtE1n53IqyqEf3PXrYwomFs5q4pGMizBMJF+ykh03insJ27hB8gSrD2Hn8A==",
+      "dev": true,
+      "engines": {
+        "node": ">= 4"
+      }
+    },
     "node_modules/@typescript-eslint/eslint-plugin/node_modules/minimatch": {
       "version": "9.0.5",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
@@ -2178,15 +2191,15 @@
       }
     },
     "node_modules/@typescript-eslint/parser": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.32.1.tgz",
-      "integrity": "sha512-oU/OtYVydhXnumd0BobL9rkJg7wFJ9bFFPmSmB/bf/XWN85hlViji59ko6bSKBXyseT9V8l+CN1nwmlbiN0G7Q==",
+      "integrity": "sha512-LKMrmwCPoLhM45Z00O1ulb6jwyVr2kr3XJp+G+tSEZcbauNnScewcQwtJqXDhXeYPDEjZ8C1SjXm015CirEmGg==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/scope-manager": "8.31.1",
+        "@typescript-eslint/scope-manager": "8.32.1",
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
-        "@typescript-eslint/typescript-estree": "8.31.1",
+        "@typescript-eslint/typescript-estree": "8.32.1",
-        "@typescript-eslint/visitor-keys": "8.31.1",
+        "@typescript-eslint/visitor-keys": "8.32.1",
         "debug": "^4.3.4"
       },
       "engines": {
@@ -2202,13 +2215,13 @@
       }
     },
     "node_modules/@typescript-eslint/parser/node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.32.1.tgz",
-      "integrity": "sha512-BMNLOElPxrtNQMIsFHE+3P0Yf1z0dJqV9zLdDxN/xLlWMlXK/ApEsVEKzpizg9oal8bAT5Sc7+ocal7AC1HCVw==",
+      "integrity": "sha512-7IsIaIDeZn7kffk7qXC3o6Z4UblZJKV3UBpkvRNpr5NSyLji7tvTcvmnMNYuYLyh26mN8W723xpo3i4MlD33vA==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
-        "@typescript-eslint/visitor-keys": "8.31.1"
+        "@typescript-eslint/visitor-keys": "8.32.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2219,9 +2232,9 @@
       }
     },
     "node_modules/@typescript-eslint/parser/node_modules/@typescript-eslint/types": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.32.1.tgz",
-      "integrity": "sha512-SfepaEFUDQYRoA70DD9GtytljBePSj17qPxFHA/h3eg6lPTqGJ5mWOtbXCk1YrVU1cTJRd14nhaXWFu0l2troQ==",
+      "integrity": "sha512-YmybwXUJcgGqgAp6bEsgpPXEg6dcCyPyCSr0CAAueacR/CCBi25G3V8gGQ2kRzQRBNol7VQknxMs9HvVa9Rvfg==",
       "dev": true,
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2232,19 +2245,19 @@
       }
     },
     "node_modules/@typescript-eslint/parser/node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.32.1.tgz",
-      "integrity": "sha512-kaA0ueLe2v7KunYOyWYtlf/QhhZb7+qh4Yw6Ni5kgukMIG+iP773tjgBiLWIXYumWCwEq3nLW+TUywEp8uEeag==",
+      "integrity": "sha512-Y3AP9EIfYwBb4kWGb+simvPaqQoT5oJuzzj9m0i6FCY6SPvlomY2Ei4UEMm7+FXtlNJbor80ximyslzaQF6xhg==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
-        "@typescript-eslint/visitor-keys": "8.31.1",
+        "@typescript-eslint/visitor-keys": "8.32.1",
         "debug": "^4.3.4",
         "fast-glob": "^3.3.2",
         "is-glob": "^4.0.3",
         "minimatch": "^9.0.4",
         "semver": "^7.6.0",
-        "ts-api-utils": "^2.0.1"
+        "ts-api-utils": "^2.1.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2258,12 +2271,12 @@
       }
     },
     "node_modules/@typescript-eslint/parser/node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.32.1.tgz",
-      "integrity": "sha512-I+/rgqOVBn6f0o7NDTmAPWWC6NuqhV174lfYvAm9fUaWeiefLdux9/YI3/nLugEn9L8fcSi0XmpKi/r5u0nmpw==",
+      "integrity": "sha512-ar0tjQfObzhSaW3C3QNmTc5ofj0hDoNQ5XWrCy6zDyabdr0TWhCkClp+rywGNj/odAFBVzzJrK4tEq5M4Hmu4w==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
         "eslint-visitor-keys": "^4.2.0"
       },
       "engines": {
@@ -2341,15 +2354,15 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.32.1.tgz",
-      "integrity": "sha512-fNaT/m9n0+dpSp8G/iOQ05GoHYXbxw81x+yvr7TArTuZuCA6VVKbqWYVZrV5dVagpDTtj/O8k5HBEE/p/HM5LA==",
+      "integrity": "sha512-mv9YpQGA8iIsl5KyUPi+FGLm7+bA4fgXaeRcFKRDRwDMu4iwrSHeDPipwueNXhdIIZltwCJv+NkxftECbIZWfA==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/typescript-estree": "8.31.1",
+        "@typescript-eslint/typescript-estree": "8.32.1",
-        "@typescript-eslint/utils": "8.31.1",
+        "@typescript-eslint/utils": "8.32.1",
         "debug": "^4.3.4",
-        "ts-api-utils": "^2.0.1"
+        "ts-api-utils": "^2.1.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2364,13 +2377,13 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils/node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.32.1.tgz",
-      "integrity": "sha512-BMNLOElPxrtNQMIsFHE+3P0Yf1z0dJqV9zLdDxN/xLlWMlXK/ApEsVEKzpizg9oal8bAT5Sc7+ocal7AC1HCVw==",
+      "integrity": "sha512-7IsIaIDeZn7kffk7qXC3o6Z4UblZJKV3UBpkvRNpr5NSyLji7tvTcvmnMNYuYLyh26mN8W723xpo3i4MlD33vA==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
-        "@typescript-eslint/visitor-keys": "8.31.1"
+        "@typescript-eslint/visitor-keys": "8.32.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2381,9 +2394,9 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils/node_modules/@typescript-eslint/types": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.32.1.tgz",
-      "integrity": "sha512-SfepaEFUDQYRoA70DD9GtytljBePSj17qPxFHA/h3eg6lPTqGJ5mWOtbXCk1YrVU1cTJRd14nhaXWFu0l2troQ==",
+      "integrity": "sha512-YmybwXUJcgGqgAp6bEsgpPXEg6dcCyPyCSr0CAAueacR/CCBi25G3V8gGQ2kRzQRBNol7VQknxMs9HvVa9Rvfg==",
       "dev": true,
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2394,19 +2407,19 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils/node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.32.1.tgz",
-      "integrity": "sha512-kaA0ueLe2v7KunYOyWYtlf/QhhZb7+qh4Yw6Ni5kgukMIG+iP773tjgBiLWIXYumWCwEq3nLW+TUywEp8uEeag==",
+      "integrity": "sha512-Y3AP9EIfYwBb4kWGb+simvPaqQoT5oJuzzj9m0i6FCY6SPvlomY2Ei4UEMm7+FXtlNJbor80ximyslzaQF6xhg==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
-        "@typescript-eslint/visitor-keys": "8.31.1",
+        "@typescript-eslint/visitor-keys": "8.32.1",
         "debug": "^4.3.4",
         "fast-glob": "^3.3.2",
         "is-glob": "^4.0.3",
         "minimatch": "^9.0.4",
         "semver": "^7.6.0",
-        "ts-api-utils": "^2.0.1"
+        "ts-api-utils": "^2.1.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2420,15 +2433,15 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils/node_modules/@typescript-eslint/utils": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.32.1.tgz",
-      "integrity": "sha512-2DSI4SNfF5T4oRveQ4nUrSjUqjMND0nLq9rEkz0gfGr3tg0S5KB6DhwR+WZPCjzkZl3cH+4x2ce3EsL50FubjQ==",
+      "integrity": "sha512-DsSFNIgLSrc89gpq1LJB7Hm1YpuhK086DRDJSNrewcGvYloWW1vZLHBTIvarKZDcAORIy/uWNx8Gad+4oMpkSA==",
       "dev": true,
       "dependencies": {
-        "@eslint-community/eslint-utils": "^4.4.0",
+        "@eslint-community/eslint-utils": "^4.7.0",
-        "@typescript-eslint/scope-manager": "8.31.1",
+        "@typescript-eslint/scope-manager": "8.32.1",
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
-        "@typescript-eslint/typescript-estree": "8.31.1"
+        "@typescript-eslint/typescript-estree": "8.32.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2443,12 +2456,12 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils/node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.31.1",
+      "version": "8.32.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.31.1.tgz",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.32.1.tgz",
-      "integrity": "sha512-I+/rgqOVBn6f0o7NDTmAPWWC6NuqhV174lfYvAm9fUaWeiefLdux9/YI3/nLugEn9L8fcSi0XmpKi/r5u0nmpw==",
+      "integrity": "sha512-ar0tjQfObzhSaW3C3QNmTc5ofj0hDoNQ5XWrCy6zDyabdr0TWhCkClp+rywGNj/odAFBVzzJrK4tEq5M4Hmu4w==",
       "dev": true,
       "dependencies": {
-        "@typescript-eslint/types": "8.31.1",
+        "@typescript-eslint/types": "8.32.1",
         "eslint-visitor-keys": "^4.2.0"
       },
       "engines": {
@@ -7541,10 +7554,9 @@
       }
     },
     "node_modules/semver": {
-      "version": "7.7.1",
+      "version": "7.7.2",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.1.tgz",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
-      "integrity": "sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
-      "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
       },

node_modules/@eslint-community/eslint-utils/README.md

@@ -30,8 +30,8 @@ Please use GitHub's Issues/PRs.
 
 ### Development Tools
 
--   `npm test` runs tests and measures coverage.
+-   `npm run test-coverage` runs tests and measures coverage.
--   `npm run clean` removes the coverage result of `npm test` command.
+-   `npm run clean` removes the coverage result of `npm run test-coverage` command.
--   `npm run coverage` shows the coverage result of the last `npm test` command.
+-   `npm run coverage` shows the coverage result of the last `npm run test-coverage` command.
 -   `npm run lint` runs ESLint.
 -   `npm run watch` runs tests on each file change.

node_modules/@eslint-community/eslint-utils/index.d.mts

@@ -0,0 +1,217 @@
+import * as eslint from 'eslint';
+import { Rule, AST } from 'eslint';
+import * as estree from 'estree';
+
+declare const READ: unique symbol;
+declare const CALL: unique symbol;
+declare const CONSTRUCT: unique symbol;
+declare const ESM: unique symbol;
+declare class ReferenceTracker {
+    constructor(globalScope: Scope$2, options?: {
+        mode?: "legacy" | "strict" | undefined;
+        globalObjectNames?: string[] | undefined;
+    } | undefined);
+    private variableStack;
+    private globalScope;
+    private mode;
+    private globalObjectNames;
+    iterateGlobalReferences<T>(traceMap: TraceMap$2<T>): IterableIterator<TrackedReferences$2<T>>;
+    iterateCjsReferences<T_1>(traceMap: TraceMap$2<T_1>): IterableIterator<TrackedReferences$2<T_1>>;
+    iterateEsmReferences<T_2>(traceMap: TraceMap$2<T_2>): IterableIterator<TrackedReferences$2<T_2>>;
+    iteratePropertyReferences<T_3>(node: Expression, traceMap: TraceMap$2<T_3>): IterableIterator<TrackedReferences$2<T_3>>;
+    private _iterateVariableReferences;
+    private _iteratePropertyReferences;
+    private _iterateLhsReferences;
+    private _iterateImportReferences;
+}
+declare namespace ReferenceTracker {
+    export { READ };
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+}
+type Scope$2 = eslint.Scope.Scope;
+type Expression = estree.Expression;
+type TraceMap$2<T> = TraceMap$1<T>;
+type TrackedReferences$2<T> = TrackedReferences$1<T>;
+
+type StaticValue$2 = StaticValueProvided$1 | StaticValueOptional$1;
+type StaticValueProvided$1 = {
+    optional?: undefined;
+    value: unknown;
+};
+type StaticValueOptional$1 = {
+    optional?: true;
+    value: undefined;
+};
+type ReferenceTrackerOptions$1 = {
+    globalObjectNames?: string[];
+    mode?: "legacy" | "strict";
+};
+type TraceMap$1<T = unknown> = {
+    [i: string]: TraceMapObject<T>;
+};
+type TraceMapObject<T> = {
+    [i: string]: TraceMapObject<T>;
+    [CALL]?: T;
+    [CONSTRUCT]?: T;
+    [READ]?: T;
+    [ESM]?: boolean;
+};
+type TrackedReferences$1<T> = {
+    info: T;
+    node: Rule.Node;
+    path: string[];
+    type: typeof CALL | typeof CONSTRUCT | typeof READ;
+};
+type HasSideEffectOptions$1 = {
+    considerGetters?: boolean;
+    considerImplicitTypeConversion?: boolean;
+};
+type PunctuatorToken<Value extends string> = AST.Token & {
+    type: "Punctuator";
+    value: Value;
+};
+type ArrowToken$1 = PunctuatorToken<"=>">;
+type CommaToken$1 = PunctuatorToken<",">;
+type SemicolonToken$1 = PunctuatorToken<";">;
+type ColonToken$1 = PunctuatorToken<":">;
+type OpeningParenToken$1 = PunctuatorToken<"(">;
+type ClosingParenToken$1 = PunctuatorToken<")">;
+type OpeningBracketToken$1 = PunctuatorToken<"[">;
+type ClosingBracketToken$1 = PunctuatorToken<"]">;
+type OpeningBraceToken$1 = PunctuatorToken<"{">;
+type ClosingBraceToken$1 = PunctuatorToken<"}">;
+
+declare function findVariable(initialScope: Scope$1, nameOrNode: string | Identifier): Variable | null;
+type Scope$1 = eslint.Scope.Scope;
+type Variable = eslint.Scope.Variable;
+type Identifier = estree.Identifier;
+
+declare function getFunctionHeadLocation(node: FunctionNode$1, sourceCode: SourceCode$2): SourceLocation | null;
+type SourceCode$2 = eslint.SourceCode;
+type FunctionNode$1 = estree.Function;
+type SourceLocation = estree.SourceLocation;
+
+declare function getFunctionNameWithKind(node: FunctionNode, sourceCode?: eslint.SourceCode | undefined): string;
+type FunctionNode = estree.Function;
+
+declare function getInnermostScope(initialScope: Scope, node: Node$4): Scope;
+type Scope = eslint.Scope.Scope;
+type Node$4 = estree.Node;
+
+declare function getPropertyName(node: MemberExpression | MethodDefinition | Property | PropertyDefinition, initialScope?: eslint.Scope.Scope | undefined): string | null | undefined;
+type MemberExpression = estree.MemberExpression;
+type MethodDefinition = estree.MethodDefinition;
+type Property = estree.Property;
+type PropertyDefinition = estree.PropertyDefinition;
+
+declare function getStaticValue(node: Node$3, initialScope?: eslint.Scope.Scope | null | undefined): StaticValue$1 | null;
+type StaticValue$1 = StaticValue$2;
+type Node$3 = estree.Node;
+
+declare function getStringIfConstant(node: Node$2, initialScope?: eslint.Scope.Scope | null | undefined): string | null;
+type Node$2 = estree.Node;
+
+declare function hasSideEffect(node: Node$1, sourceCode: SourceCode$1, options?: HasSideEffectOptions$1 | undefined): boolean;
+type Node$1 = estree.Node;
+type SourceCode$1 = eslint.SourceCode;
+
+declare function isArrowToken(token: CommentOrToken): token is ArrowToken$1;
+declare function isCommaToken(token: CommentOrToken): token is CommaToken$1;
+declare function isSemicolonToken(token: CommentOrToken): token is SemicolonToken$1;
+declare function isColonToken(token: CommentOrToken): token is ColonToken$1;
+declare function isOpeningParenToken(token: CommentOrToken): token is OpeningParenToken$1;
+declare function isClosingParenToken(token: CommentOrToken): token is ClosingParenToken$1;
+declare function isOpeningBracketToken(token: CommentOrToken): token is OpeningBracketToken$1;
+declare function isClosingBracketToken(token: CommentOrToken): token is ClosingBracketToken$1;
+declare function isOpeningBraceToken(token: CommentOrToken): token is OpeningBraceToken$1;
+declare function isClosingBraceToken(token: CommentOrToken): token is ClosingBraceToken$1;
+declare function isCommentToken(token: CommentOrToken): token is estree.Comment;
+declare function isNotArrowToken(arg0: CommentOrToken): boolean;
+declare function isNotCommaToken(arg0: CommentOrToken): boolean;
+declare function isNotSemicolonToken(arg0: CommentOrToken): boolean;
+declare function isNotColonToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningParenToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingParenToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotCommentToken(arg0: CommentOrToken): boolean;
+type Token = eslint.AST.Token;
+type Comment = estree.Comment;
+type CommentOrToken = Comment | Token;
+
+declare function isParenthesized(timesOrNode: Node | number, nodeOrSourceCode: Node | SourceCode, optionalSourceCode?: eslint.SourceCode | undefined): boolean;
+type Node = estree.Node;
+type SourceCode = eslint.SourceCode;
+
+declare class PatternMatcher {
+    constructor(pattern: RegExp, options?: {
+        escaped?: boolean | undefined;
+    } | undefined);
+    execAll(str: string): IterableIterator<RegExpExecArray>;
+    test(str: string): boolean;
+    [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string;
+}
+
+declare namespace _default {
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+    export { findVariable };
+    export { getFunctionHeadLocation };
+    export { getFunctionNameWithKind };
+    export { getInnermostScope };
+    export { getPropertyName };
+    export { getStaticValue };
+    export { getStringIfConstant };
+    export { hasSideEffect };
+    export { isArrowToken };
+    export { isClosingBraceToken };
+    export { isClosingBracketToken };
+    export { isClosingParenToken };
+    export { isColonToken };
+    export { isCommaToken };
+    export { isCommentToken };
+    export { isNotArrowToken };
+    export { isNotClosingBraceToken };
+    export { isNotClosingBracketToken };
+    export { isNotClosingParenToken };
+    export { isNotColonToken };
+    export { isNotCommaToken };
+    export { isNotCommentToken };
+    export { isNotOpeningBraceToken };
+    export { isNotOpeningBracketToken };
+    export { isNotOpeningParenToken };
+    export { isNotSemicolonToken };
+    export { isOpeningBraceToken };
+    export { isOpeningBracketToken };
+    export { isOpeningParenToken };
+    export { isParenthesized };
+    export { isSemicolonToken };
+    export { PatternMatcher };
+    export { READ };
+    export { ReferenceTracker };
+}
+
+type StaticValue = StaticValue$2;
+type StaticValueOptional = StaticValueOptional$1;
+type StaticValueProvided = StaticValueProvided$1;
+type ReferenceTrackerOptions = ReferenceTrackerOptions$1;
+type TraceMap<T> = TraceMap$1<T>;
+type TrackedReferences<T> = TrackedReferences$1<T>;
+type HasSideEffectOptions = HasSideEffectOptions$1;
+type ArrowToken = ArrowToken$1;
+type CommaToken = CommaToken$1;
+type SemicolonToken = SemicolonToken$1;
+type ColonToken = ColonToken$1;
+type OpeningParenToken = OpeningParenToken$1;
+type ClosingParenToken = ClosingParenToken$1;
+type OpeningBracketToken = OpeningBracketToken$1;
+type ClosingBracketToken = ClosingBracketToken$1;
+type OpeningBraceToken = OpeningBraceToken$1;
+type ClosingBraceToken = ClosingBraceToken$1;
+
+export { ArrowToken, CALL, CONSTRUCT, ClosingBraceToken, ClosingBracketToken, ClosingParenToken, ColonToken, CommaToken, ESM, HasSideEffectOptions, OpeningBraceToken, OpeningBracketToken, OpeningParenToken, PatternMatcher, READ, ReferenceTracker, ReferenceTrackerOptions, SemicolonToken, StaticValue, StaticValueOptional, StaticValueProvided, TraceMap, TrackedReferences, _default as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken };

node_modules/@eslint-community/eslint-utils/index.d.ts

@@ -0,0 +1,217 @@
+import * as eslint from 'eslint';
+import { Rule, AST } from 'eslint';
+import * as estree from 'estree';
+
+declare const READ: unique symbol;
+declare const CALL: unique symbol;
+declare const CONSTRUCT: unique symbol;
+declare const ESM: unique symbol;
+declare class ReferenceTracker {
+    constructor(globalScope: Scope$2, options?: {
+        mode?: "legacy" | "strict" | undefined;
+        globalObjectNames?: string[] | undefined;
+    } | undefined);
+    private variableStack;
+    private globalScope;
+    private mode;
+    private globalObjectNames;
+    iterateGlobalReferences<T>(traceMap: TraceMap$2<T>): IterableIterator<TrackedReferences$2<T>>;
+    iterateCjsReferences<T_1>(traceMap: TraceMap$2<T_1>): IterableIterator<TrackedReferences$2<T_1>>;
+    iterateEsmReferences<T_2>(traceMap: TraceMap$2<T_2>): IterableIterator<TrackedReferences$2<T_2>>;
+    iteratePropertyReferences<T_3>(node: Expression, traceMap: TraceMap$2<T_3>): IterableIterator<TrackedReferences$2<T_3>>;
+    private _iterateVariableReferences;
+    private _iteratePropertyReferences;
+    private _iterateLhsReferences;
+    private _iterateImportReferences;
+}
+declare namespace ReferenceTracker {
+    export { READ };
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+}
+type Scope$2 = eslint.Scope.Scope;
+type Expression = estree.Expression;
+type TraceMap$2<T> = TraceMap$1<T>;
+type TrackedReferences$2<T> = TrackedReferences$1<T>;
+
+type StaticValue$2 = StaticValueProvided$1 | StaticValueOptional$1;
+type StaticValueProvided$1 = {
+    optional?: undefined;
+    value: unknown;
+};
+type StaticValueOptional$1 = {
+    optional?: true;
+    value: undefined;
+};
+type ReferenceTrackerOptions$1 = {
+    globalObjectNames?: string[];
+    mode?: "legacy" | "strict";
+};
+type TraceMap$1<T = unknown> = {
+    [i: string]: TraceMapObject<T>;
+};
+type TraceMapObject<T> = {
+    [i: string]: TraceMapObject<T>;
+    [CALL]?: T;
+    [CONSTRUCT]?: T;
+    [READ]?: T;
+    [ESM]?: boolean;
+};
+type TrackedReferences$1<T> = {
+    info: T;
+    node: Rule.Node;
+    path: string[];
+    type: typeof CALL | typeof CONSTRUCT | typeof READ;
+};
+type HasSideEffectOptions$1 = {
+    considerGetters?: boolean;
+    considerImplicitTypeConversion?: boolean;
+};
+type PunctuatorToken<Value extends string> = AST.Token & {
+    type: "Punctuator";
+    value: Value;
+};
+type ArrowToken$1 = PunctuatorToken<"=>">;
+type CommaToken$1 = PunctuatorToken<",">;
+type SemicolonToken$1 = PunctuatorToken<";">;
+type ColonToken$1 = PunctuatorToken<":">;
+type OpeningParenToken$1 = PunctuatorToken<"(">;
+type ClosingParenToken$1 = PunctuatorToken<")">;
+type OpeningBracketToken$1 = PunctuatorToken<"[">;
+type ClosingBracketToken$1 = PunctuatorToken<"]">;
+type OpeningBraceToken$1 = PunctuatorToken<"{">;
+type ClosingBraceToken$1 = PunctuatorToken<"}">;
+
+declare function findVariable(initialScope: Scope$1, nameOrNode: string | Identifier): Variable | null;
+type Scope$1 = eslint.Scope.Scope;
+type Variable = eslint.Scope.Variable;
+type Identifier = estree.Identifier;
+
+declare function getFunctionHeadLocation(node: FunctionNode$1, sourceCode: SourceCode$2): SourceLocation | null;
+type SourceCode$2 = eslint.SourceCode;
+type FunctionNode$1 = estree.Function;
+type SourceLocation = estree.SourceLocation;
+
+declare function getFunctionNameWithKind(node: FunctionNode, sourceCode?: eslint.SourceCode | undefined): string;
+type FunctionNode = estree.Function;
+
+declare function getInnermostScope(initialScope: Scope, node: Node$4): Scope;
+type Scope = eslint.Scope.Scope;
+type Node$4 = estree.Node;
+
+declare function getPropertyName(node: MemberExpression | MethodDefinition | Property | PropertyDefinition, initialScope?: eslint.Scope.Scope | undefined): string | null | undefined;
+type MemberExpression = estree.MemberExpression;
+type MethodDefinition = estree.MethodDefinition;
+type Property = estree.Property;
+type PropertyDefinition = estree.PropertyDefinition;
+
+declare function getStaticValue(node: Node$3, initialScope?: eslint.Scope.Scope | null | undefined): StaticValue$1 | null;
+type StaticValue$1 = StaticValue$2;
+type Node$3 = estree.Node;
+
+declare function getStringIfConstant(node: Node$2, initialScope?: eslint.Scope.Scope | null | undefined): string | null;
+type Node$2 = estree.Node;
+
+declare function hasSideEffect(node: Node$1, sourceCode: SourceCode$1, options?: HasSideEffectOptions$1 | undefined): boolean;
+type Node$1 = estree.Node;
+type SourceCode$1 = eslint.SourceCode;
+
+declare function isArrowToken(token: CommentOrToken): token is ArrowToken$1;
+declare function isCommaToken(token: CommentOrToken): token is CommaToken$1;
+declare function isSemicolonToken(token: CommentOrToken): token is SemicolonToken$1;
+declare function isColonToken(token: CommentOrToken): token is ColonToken$1;
+declare function isOpeningParenToken(token: CommentOrToken): token is OpeningParenToken$1;
+declare function isClosingParenToken(token: CommentOrToken): token is ClosingParenToken$1;
+declare function isOpeningBracketToken(token: CommentOrToken): token is OpeningBracketToken$1;
+declare function isClosingBracketToken(token: CommentOrToken): token is ClosingBracketToken$1;
+declare function isOpeningBraceToken(token: CommentOrToken): token is OpeningBraceToken$1;
+declare function isClosingBraceToken(token: CommentOrToken): token is ClosingBraceToken$1;
+declare function isCommentToken(token: CommentOrToken): token is estree.Comment;
+declare function isNotArrowToken(arg0: CommentOrToken): boolean;
+declare function isNotCommaToken(arg0: CommentOrToken): boolean;
+declare function isNotSemicolonToken(arg0: CommentOrToken): boolean;
+declare function isNotColonToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningParenToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingParenToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBracketToken(arg0: CommentOrToken): boolean;
+declare function isNotOpeningBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotClosingBraceToken(arg0: CommentOrToken): boolean;
+declare function isNotCommentToken(arg0: CommentOrToken): boolean;
+type Token = eslint.AST.Token;
+type Comment = estree.Comment;
+type CommentOrToken = Comment | Token;
+
+declare function isParenthesized(timesOrNode: Node | number, nodeOrSourceCode: Node | SourceCode, optionalSourceCode?: eslint.SourceCode | undefined): boolean;
+type Node = estree.Node;
+type SourceCode = eslint.SourceCode;
+
+declare class PatternMatcher {
+    constructor(pattern: RegExp, options?: {
+        escaped?: boolean | undefined;
+    } | undefined);
+    execAll(str: string): IterableIterator<RegExpExecArray>;
+    test(str: string): boolean;
+    [Symbol.replace](str: string, replacer: string | ((...strs: string[]) => string)): string;
+}
+
+declare namespace _default {
+    export { CALL };
+    export { CONSTRUCT };
+    export { ESM };
+    export { findVariable };
+    export { getFunctionHeadLocation };
+    export { getFunctionNameWithKind };
+    export { getInnermostScope };
+    export { getPropertyName };
+    export { getStaticValue };
+    export { getStringIfConstant };
+    export { hasSideEffect };
+    export { isArrowToken };
+    export { isClosingBraceToken };
+    export { isClosingBracketToken };
+    export { isClosingParenToken };
+    export { isColonToken };
+    export { isCommaToken };
+    export { isCommentToken };
+    export { isNotArrowToken };
+    export { isNotClosingBraceToken };
+    export { isNotClosingBracketToken };
+    export { isNotClosingParenToken };
+    export { isNotColonToken };
+    export { isNotCommaToken };
+    export { isNotCommentToken };
+    export { isNotOpeningBraceToken };
+    export { isNotOpeningBracketToken };
+    export { isNotOpeningParenToken };
+    export { isNotSemicolonToken };
+    export { isOpeningBraceToken };
+    export { isOpeningBracketToken };
+    export { isOpeningParenToken };
+    export { isParenthesized };
+    export { isSemicolonToken };
+    export { PatternMatcher };
+    export { READ };
+    export { ReferenceTracker };
+}
+
+type StaticValue = StaticValue$2;
+type StaticValueOptional = StaticValueOptional$1;
+type StaticValueProvided = StaticValueProvided$1;
+type ReferenceTrackerOptions = ReferenceTrackerOptions$1;
+type TraceMap<T> = TraceMap$1<T>;
+type TrackedReferences<T> = TrackedReferences$1<T>;
+type HasSideEffectOptions = HasSideEffectOptions$1;
+type ArrowToken = ArrowToken$1;
+type CommaToken = CommaToken$1;
+type SemicolonToken = SemicolonToken$1;
+type ColonToken = ColonToken$1;
+type OpeningParenToken = OpeningParenToken$1;
+type ClosingParenToken = ClosingParenToken$1;
+type OpeningBracketToken = OpeningBracketToken$1;
+type ClosingBracketToken = ClosingBracketToken$1;
+type OpeningBraceToken = OpeningBraceToken$1;
+type ClosingBraceToken = ClosingBraceToken$1;
+
+export { ArrowToken, CALL, CONSTRUCT, ClosingBraceToken, ClosingBracketToken, ClosingParenToken, ColonToken, CommaToken, ESM, HasSideEffectOptions, OpeningBraceToken, OpeningBracketToken, OpeningParenToken, PatternMatcher, READ, ReferenceTracker, ReferenceTrackerOptions, SemicolonToken, StaticValue, StaticValueOptional, StaticValueProvided, TraceMap, TrackedReferences, _default as default, findVariable, getFunctionHeadLocation, getFunctionNameWithKind, getInnermostScope, getPropertyName, getStaticValue, getStringIfConstant, hasSideEffect, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isNotArrowToken, isNotClosingBraceToken, isNotClosingBracketToken, isNotClosingParenToken, isNotColonToken, isNotCommaToken, isNotCommentToken, isNotOpeningBraceToken, isNotOpeningBracketToken, isNotOpeningParenToken, isNotSemicolonToken, isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isParenthesized, isSemicolonToken };

node_modules/@eslint-community/eslint-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-community/eslint-utils",
-  "version": "4.4.0",
+  "version": "4.7.0",
   "description": "Utilities for ESLint plugins.",
   "keywords": [
     "eslint"
@@ -30,38 +30,53 @@
   ],
   "scripts": {
     "prebuild": "npm run -s clean",
-    "build": "rollup -c",
+    "build": "npm run build:dts && npm run build:rollup",
-    "clean": "rimraf .nyc_output coverage index.*",
+    "build:dts": "tsc -p tsconfig.build.json",
+    "build:rollup": "rollup -c",
+    "clean": "rimraf .nyc_output coverage index.* dist",
     "coverage": "opener ./coverage/lcov-report/index.html",
     "docs:build": "vitepress build docs",
     "docs:watch": "vitepress dev docs",
     "format": "npm run -s format:prettier -- --write",
     "format:prettier": "prettier .",
     "format:check": "npm run -s format:prettier -- --check",
-    "lint": "eslint .",
+    "lint:eslint": "eslint .",
-    "test": "c8 mocha --reporter dot \"test/*.mjs\"",
+    "lint:format": "npm run -s format:check",
-    "preversion": "npm test && npm run -s build",
+    "lint:installed-check": "installed-check -v -i installed-check -i npm-run-all2 -i knip -i rollup-plugin-dts",
+    "lint:knip": "knip",
+    "lint": "run-p lint:*",
+    "test-coverage": "c8 mocha --reporter dot \"test/*.mjs\"",
+    "test": "mocha --reporter dot \"test/*.mjs\"",
+    "preversion": "npm run test-coverage && npm run -s build",
     "postversion": "git push && git push --tags",
     "prewatch": "npm run -s clean",
     "watch": "warun \"{src,test}/**/*.mjs\" -- npm run -s test:mocha"
   },
   "dependencies": {
-    "eslint-visitor-keys": "^3.3.0"
+    "eslint-visitor-keys": "^3.4.3"
   },
   "devDependencies": {
-    "@eslint-community/eslint-plugin-mysticatea": "^15.2.0",
+    "@eslint-community/eslint-plugin-mysticatea": "^15.6.1",
-    "c8": "^7.12.0",
+    "@types/eslint": "^9.6.1",
-    "dot-prop": "^6.0.1",
+    "@types/estree": "^1.0.7",
-    "eslint": "^8.28.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "@typescript-eslint/types": "^5.62.0",
+    "c8": "^8.0.1",
+    "dot-prop": "^7.2.0",
+    "eslint": "^8.57.1",
+    "installed-check": "^8.0.1",
+    "knip": "^5.33.3",
     "mocha": "^9.2.2",
-    "npm-run-all": "^4.1.5",
+    "npm-run-all2": "^6.2.3",
     "opener": "^1.5.2",
-    "prettier": "2.8.4",
+    "prettier": "2.8.8",
     "rimraf": "^3.0.2",
-    "rollup": "^2.79.1",
+    "rollup": "^2.79.2",
+    "rollup-plugin-dts": "^4.2.3",
     "rollup-plugin-sourcemaps": "^0.6.3",
-    "semver": "^7.3.8",
+    "semver": "^7.6.3",
-    "vitepress": "^1.0.0-alpha.40",
+    "typescript": "^4.9.5",
+    "vitepress": "^1.4.1",
     "warun": "^1.0.0"
   },
   "peerDependencies": {
@@ -69,5 +84,6 @@
   },
   "engines": {
     "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-  }
+  },
+  "funding": "https://opencollective.com/eslint"
 }

node_modules/@eslint/js/README.md

@@ -8,8 +8,8 @@ The beginnings of separating out JavaScript-specific functionality from ESLint.
 
 Right now, this plugin contains two configurations:
 
--   `recommended` - enables the rules recommended by the ESLint team (the replacement for `"eslint:recommended"`)
+- `recommended` - enables the rules recommended by the ESLint team (the replacement for `"eslint:recommended"`)
--   `all` - enables all ESLint rules (the replacement for `"eslint:all"`)
+- `all` - enables all ESLint rules (the replacement for `"eslint:all"`)
 
 ## Installation
 

node_modules/@eslint/js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint/js",
-  "version": "9.25.1",
+  "version": "9.26.0",
   "description": "ESLint JavaScript language implementation",
   "main": "./src/index.js",
   "types": "./types/index.d.ts",

node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.d.ts

@@ -89,6 +89,7 @@ declare const _default: {
         '@typescript-eslint/no-unnecessary-type-arguments': "error";
         '@typescript-eslint/no-unnecessary-type-assertion': "error";
         '@typescript-eslint/no-unnecessary-type-constraint': "error";
+        '@typescript-eslint/no-unnecessary-type-conversion': "error";
         '@typescript-eslint/no-unnecessary-type-parameters': "error";
         '@typescript-eslint/no-unsafe-argument': "error";
         '@typescript-eslint/no-unsafe-assignment': "error";

node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/all.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBAyJiC"}
+{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/all.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA0JiC"}

node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/all.js

@@ -96,6 +96,7 @@ module.exports = {
         '@typescript-eslint/no-unnecessary-type-arguments': 'error',
         '@typescript-eslint/no-unnecessary-type-assertion': 'error',
         '@typescript-eslint/no-unnecessary-type-constraint': 'error',
+        '@typescript-eslint/no-unnecessary-type-conversion': 'error',
         '@typescript-eslint/no-unnecessary-type-parameters': 'error',
         '@typescript-eslint/no-unsafe-argument': 'error',
         '@typescript-eslint/no-unsafe-assignment': 'error',

node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.d.ts

@@ -29,6 +29,7 @@ declare const _default: {
         '@typescript-eslint/no-unnecessary-template-expression': "off";
         '@typescript-eslint/no-unnecessary-type-arguments': "off";
         '@typescript-eslint/no-unnecessary-type-assertion': "off";
+        '@typescript-eslint/no-unnecessary-type-conversion': "off";
         '@typescript-eslint/no-unnecessary-type-parameters': "off";
         '@typescript-eslint/no-unsafe-argument': "off";
         '@typescript-eslint/no-unsafe-assignment': "off";

node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/disable-type-checked.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA8DiC"}
+{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/disable-type-checked.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA+DiC"}

node_modules/@typescript-eslint/eslint-plugin/dist/configs/eslintrc/disable-type-checked.js

@@ -32,6 +32,7 @@ module.exports = {
         '@typescript-eslint/no-unnecessary-template-expression': 'off',
         '@typescript-eslint/no-unnecessary-type-arguments': 'off',
         '@typescript-eslint/no-unnecessary-type-assertion': 'off',
+        '@typescript-eslint/no-unnecessary-type-conversion': 'off',
         '@typescript-eslint/no-unnecessary-type-parameters': 'off',
         '@typescript-eslint/no-unsafe-argument': 'off',
         '@typescript-eslint/no-unsafe-assignment': 'off',

node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/all.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAKrE;;;GAGG;yBAED,QAAQ,UAAU,CAAC,MAAM,EACzB,QAAQ,UAAU,CAAC,MAAM,KACxB,UAAU,CAAC,WAAW;AAHzB,wBAiKE"}
+{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/all.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAKrE;;;GAGG;yBAED,QAAQ,UAAU,CAAC,MAAM,EACzB,QAAQ,UAAU,CAAC,MAAM,KACxB,UAAU,CAAC,WAAW;AAHzB,wBAkKE"}

node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/all.js

@@ -109,6 +109,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-unnecessary-type-arguments': 'error',
             '@typescript-eslint/no-unnecessary-type-assertion': 'error',
             '@typescript-eslint/no-unnecessary-type-constraint': 'error',
+            '@typescript-eslint/no-unnecessary-type-conversion': 'error',
             '@typescript-eslint/no-unnecessary-type-parameters': 'error',
             '@typescript-eslint/no-unsafe-argument': 'error',
             '@typescript-eslint/no-unsafe-assignment': 'error',

node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/disable-type-checked.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAErE;;;GAGG;yBAED,SAAS,UAAU,CAAC,MAAM,EAC1B,SAAS,UAAU,CAAC,MAAM,KACzB,UAAU,CAAC,MAAM;AAHpB,wBAoEG"}
+{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/disable-type-checked.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAErE;;;GAGG;yBAED,SAAS,UAAU,CAAC,MAAM,EAC1B,SAAS,UAAU,CAAC,MAAM,KACzB,UAAU,CAAC,MAAM;AAHpB,wBAqEG"}

node_modules/@typescript-eslint/eslint-plugin/dist/configs/flat/disable-type-checked.js

@@ -37,6 +37,7 @@ exports.default = (_plugin, _parser) => ({
         '@typescript-eslint/no-unnecessary-template-expression': 'off',
         '@typescript-eslint/no-unnecessary-type-arguments': 'off',
         '@typescript-eslint/no-unnecessary-type-assertion': 'off',
+        '@typescript-eslint/no-unnecessary-type-conversion': 'off',
         '@typescript-eslint/no-unnecessary-type-parameters': 'off',
         '@typescript-eslint/no-unsafe-argument': 'off',
         '@typescript-eslint/no-unsafe-assignment': 'off',

node_modules/@typescript-eslint/eslint-plugin/dist/index.d.ts

@@ -91,6 +91,7 @@ declare const _default: {
                 '@typescript-eslint/no-unnecessary-type-arguments': "error";
                 '@typescript-eslint/no-unnecessary-type-assertion': "error";
                 '@typescript-eslint/no-unnecessary-type-constraint': "error";
+                '@typescript-eslint/no-unnecessary-type-conversion': "error";
                 '@typescript-eslint/no-unnecessary-type-parameters': "error";
                 '@typescript-eslint/no-unsafe-argument': "error";
                 '@typescript-eslint/no-unsafe-assignment': "error";
@@ -192,6 +193,7 @@ declare const _default: {
                 '@typescript-eslint/no-unnecessary-template-expression': "off";
                 '@typescript-eslint/no-unnecessary-type-arguments': "off";
                 '@typescript-eslint/no-unnecessary-type-assertion': "off";
+                '@typescript-eslint/no-unnecessary-type-conversion': "off";
                 '@typescript-eslint/no-unnecessary-type-parameters': "off";
                 '@typescript-eslint/no-unsafe-argument': "off";
                 '@typescript-eslint/no-unsafe-assignment': "off";
@@ -774,6 +776,7 @@ declare const _default: {
         'no-unnecessary-type-arguments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unnecessary-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-unnecessary-type-assertion").MessageIds, import("./rules/no-unnecessary-type-assertion").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unnecessary-type-constraint': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'no-unnecessary-type-conversion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unnecessary-type-parameters': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-argument': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-unsafe-argument").MessageIds, [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeArraySpread" | "anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeAssignment", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

node_modules/@typescript-eslint/eslint-plugin/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,kBAA0B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,kBAA0B"}

node_modules/@typescript-eslint/eslint-plugin/dist/raw-plugin.d.ts

@@ -113,6 +113,7 @@ declare const _default: {
                     '@typescript-eslint/no-unnecessary-type-arguments': "error";
                     '@typescript-eslint/no-unnecessary-type-assertion': "error";
                     '@typescript-eslint/no-unnecessary-type-constraint': "error";
+                    '@typescript-eslint/no-unnecessary-type-conversion': "error";
                     '@typescript-eslint/no-unnecessary-type-parameters': "error";
                     '@typescript-eslint/no-unsafe-argument': "error";
                     '@typescript-eslint/no-unsafe-assignment': "error";
@@ -214,6 +215,7 @@ declare const _default: {
                     '@typescript-eslint/no-unnecessary-template-expression': "off";
                     '@typescript-eslint/no-unnecessary-type-arguments': "off";
                     '@typescript-eslint/no-unnecessary-type-assertion': "off";
+                    '@typescript-eslint/no-unnecessary-type-conversion': "off";
                     '@typescript-eslint/no-unnecessary-type-parameters': "off";
                     '@typescript-eslint/no-unsafe-argument': "off";
                     '@typescript-eslint/no-unsafe-assignment': "off";
@@ -797,6 +799,7 @@ declare const _default: {
             'no-unnecessary-type-arguments': TSESLint.RuleModule<"unnecessaryTypeParameter", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unnecessary-type-assertion': TSESLint.RuleModule<import("./rules/no-unnecessary-type-assertion").MessageIds, import("./rules/no-unnecessary-type-assertion").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unnecessary-type-constraint': TSESLint.RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+            'no-unnecessary-type-conversion': TSESLint.RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unnecessary-type-parameters': TSESLint.RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-argument': TSESLint.RuleModule<import("./rules/no-unsafe-argument").MessageIds, [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-assignment': TSESLint.RuleModule<"unsafeArraySpread" | "anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeAssignment", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;

node_modules/@typescript-eslint/eslint-plugin/dist/raw-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raw-plugin.d.ts","sourceRoot":"","sources":["../src/raw-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,oCAAoC,CAAC;;;;;;;;;;;;;;;;;;wDAetD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqCpB,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDvE,kBAIE"}
+{"version":3,"file":"raw-plugin.d.ts","sourceRoot":"","sources":["../src/raw-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,oCAAoC,CAAC;;;;;;;;;;;;;;;;;;wDAetD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqCpB,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDvE,kBAIE"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/adjacent-overload-signatures.js

@@ -50,7 +50,7 @@ exports.default = (0, util_1.createRule)({
                     return {
                         ...(0, util_1.getNameFromMember)(member, context.sourceCode),
                         callSignature: false,
-                        static: !!member.static,
+                        static: member.static,
                     };
                 case utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration:
                     return {

node_modules/@typescript-eslint/eslint-plugin/dist/rules/await-thenable.js

@@ -87,7 +87,7 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 const hasAsyncIteratorSymbol = tsutils
-                    .unionTypeParts(type)
+                    .unionConstituents(type)
                     .some(typePart => tsutils.getWellKnownSymbolPropertyOfType(typePart, 'asyncIterator', checker) != null);
                 if (!hasAsyncIteratorSymbol) {
                     context.report({
@@ -118,7 +118,7 @@ exports.default = (0, util_1.createRule)({
                         continue;
                     }
                     const hasAsyncDisposeSymbol = tsutils
-                        .unionTypeParts(type)
+                        .unionConstituents(type)
                         .some(typePart => tsutils.getWellKnownSymbolPropertyOfType(typePart, 'asyncDispose', checker) != null);
                     if (!hasAsyncDisposeSymbol) {
                         context.report({

node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-indexed-object-style.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consistent-indexed-object-style.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-indexed-object-style.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAanE,MAAM,MAAM,UAAU,GAClB,sBAAsB,GACtB,gCAAgC,GAChC,cAAc,CAAC;AACnB,MAAM,MAAM,OAAO,GAAG,CAAC,iBAAiB,GAAG,QAAQ,CAAC,CAAC;;AAErD,wBA4OG"}
+{"version":3,"file":"consistent-indexed-object-style.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-indexed-object-style.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAanE,MAAM,MAAM,UAAU,GAClB,sBAAsB,GACtB,gCAAgC,GAChC,cAAc,CAAC;AACnB,MAAM,MAAM,OAAO,GAAG,CAAC,iBAAiB,GAAG,QAAQ,CAAC,CAAC;;AAErD,wBA2OG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-indexed-object-style.js

@@ -139,9 +139,7 @@ exports.default = (0, util_1.createRule)({
                         const scope = context.sourceCode.getScope(key);
                         const superVar = utils_1.ASTUtils.findVariable(scope, parentId.name);
                         if (superVar) {
-                            const isCircular = superVar.references.some(item => item.isTypeReference &&
+                            const isCircular = isDeeplyReferencingType(node.parent, superVar, new Set([parentId]));
-                                node.range[0] <= item.identifier.range[0] &&
-                                node.range[1] >= item.identifier.range[1]);
                             if (isCircular) {
                                 return;
                             }
@@ -155,7 +153,9 @@ exports.default = (0, util_1.createRule)({
                         ...(canFix && {
                             fix: (fixer) => {
                                 const keyType = context.sourceCode.getText(constraint);
-                                const valueType = context.sourceCode.getText(node.typeAnnotation);
+                                const valueType = node.typeAnnotation
+                                    ? context.sourceCode.getText(node.typeAnnotation)
+                                    : 'any';
                                 let recordText = `Record<${keyType}, ${valueType}>`;
                                 if (node.optional === '+' || node.optional === true) {
                                     recordText = `Partial<${recordText}>`;
@@ -201,6 +201,11 @@ function isDeeplyReferencingType(node, superVar, visited) {
             return isDeeplyReferencingType(node.typeAnnotation, superVar, visited);
         case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
             return [node.indexType, node.objectType].some(type => isDeeplyReferencingType(type, superVar, visited));
+        case utils_1.AST_NODE_TYPES.TSMappedType:
+            if (node.typeAnnotation) {
+                return isDeeplyReferencingType(node.typeAnnotation, superVar, visited);
+            }
+            break;
         case utils_1.AST_NODE_TYPES.TSConditionalType:
             return [
                 node.checkType,

node_modules/@typescript-eslint/eslint-plugin/dist/rules/enum-utils/shared.js

@@ -66,7 +66,7 @@ function getBaseEnumType(typeChecker, type) {
  */
 function getEnumLiterals(type) {
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
         .filter((subType) => (0, util_1.isTypeFlagSet)(subType, ts.TypeFlags.EnumLiteral));
 }
 /**

node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.js

@@ -116,13 +116,13 @@ exports.default = (0, util_1.createRule)({
                         }
                     }
                 }
-                if (!!funcName && !!options.allowedNames.includes(funcName)) {
+                if (!!funcName && options.allowedNames.includes(funcName)) {
                     return true;
                 }
             }
             if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
                 node.id &&
-                !!options.allowedNames.includes(node.id.name)) {
+                options.allowedNames.includes(node.id.name)) {
                 return true;
             }
             return false;

node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.d.ts

@@ -107,6 +107,7 @@ declare const rules: {
     'no-unnecessary-type-arguments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unnecessary-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unnecessary-type-assertion").MessageIds, import("./no-unnecessary-type-assertion").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unnecessary-type-constraint': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-type-conversion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unnecessary-type-parameters': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-argument': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unsafe-argument").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeArraySpread" | "anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeAssignment", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAqIA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoImB,CAAC;AAE/B,SAAS,KAAK,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAsIA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqImB,CAAC;AAE/B,SAAS,KAAK,CAAC"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/index.js

@@ -77,6 +77,7 @@ const no_unnecessary_template_expression_1 = __importDefault(require("./no-unnec
 const no_unnecessary_type_arguments_1 = __importDefault(require("./no-unnecessary-type-arguments"));
 const no_unnecessary_type_assertion_1 = __importDefault(require("./no-unnecessary-type-assertion"));
 const no_unnecessary_type_constraint_1 = __importDefault(require("./no-unnecessary-type-constraint"));
+const no_unnecessary_type_conversion_1 = __importDefault(require("./no-unnecessary-type-conversion"));
 const no_unnecessary_type_parameters_1 = __importDefault(require("./no-unnecessary-type-parameters"));
 const no_unsafe_argument_1 = __importDefault(require("./no-unsafe-argument"));
 const no_unsafe_assignment_1 = __importDefault(require("./no-unsafe-assignment"));
@@ -208,6 +209,7 @@ const rules = {
     'no-unnecessary-type-arguments': no_unnecessary_type_arguments_1.default,
     'no-unnecessary-type-assertion': no_unnecessary_type_assertion_1.default,
     'no-unnecessary-type-constraint': no_unnecessary_type_constraint_1.default,
+    'no-unnecessary-type-conversion': no_unnecessary_type_conversion_1.default,
     'no-unnecessary-type-parameters': no_unnecessary_type_parameters_1.default,
     'no-unsafe-argument': no_unsafe_argument_1.default,
     'no-unsafe-assignment': no_unsafe_assignment_1.default,

node_modules/@typescript-eslint/eslint-plugin/dist/rules/member-ordering.js

@@ -326,7 +326,7 @@ function isMemberOptional(node) {
         case utils_1.AST_NODE_TYPES.PropertyDefinition:
         case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition:
         case utils_1.AST_NODE_TYPES.MethodDefinition:
-            return !!node.optional;
+            return node.optional;
     }
     return false;
 }

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-confusing-void-expression.js

@@ -327,7 +327,7 @@ exports.default = (0, util_1.createRule)({
             return callSignatures.some(signature => {
                 const returnType = signature.getReturnType();
                 return tsutils
-                    .unionTypeParts(returnType)
+                    .unionConstituents(returnType)
                     .some(tsutils.isIntrinsicVoidType);
             });
         }
@@ -342,14 +342,14 @@ exports.default = (0, util_1.createRule)({
             if (functionTSNode.type) {
                 const returnType = checker.getTypeFromTypeNode(functionTSNode.type);
                 return tsutils
-                    .unionTypeParts(returnType)
+                    .unionConstituents(returnType)
                     .some(tsutils.isIntrinsicVoidType);
             }
             if (ts.isExpression(functionTSNode)) {
                 const functionType = checker.getContextualType(functionTSNode);
                 if (functionType) {
                     return tsutils
-                        .unionTypeParts(functionType)
+                        .unionConstituents(functionType)
                         .some(isFunctionReturnTypeIncludesVoid);
                 }
             }

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-deprecated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-deprecated.d.ts","sourceRoot":"","sources":["../../src/rules/no-deprecated.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAgBpD,KAAK,UAAU,GAAG,YAAY,GAAG,sBAAsB,CAAC;AAExD,KAAK,OAAO,GAAG;IACb;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;KAChC;CACF,CAAC;;AAEF,wBA0XG"}
+{"version":3,"file":"no-deprecated.d.ts","sourceRoot":"","sources":["../../src/rules/no-deprecated.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAgBpD,KAAK,UAAU,GAAG,YAAY,GAAG,sBAAsB,CAAC;AAExD,KAAK,OAAO,GAAG;IACb;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;KAChC;CACF,CAAC;;AAEF,wBAmaG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-deprecated.js

@@ -318,6 +318,38 @@ exports.default = (0, util_1.createRule)({
                 node,
             });
         }
+        function checkMemberExpression(node) {
+            if (!node.computed) {
+                return;
+            }
+            const propertyType = services.getTypeAtLocation(node.property);
+            if (propertyType.isLiteral()) {
+                const objectType = services.getTypeAtLocation(node.object);
+                const propertyName = propertyType.isStringLiteral()
+                    ? propertyType.value
+                    : String(propertyType.value);
+                const property = objectType.getProperty(propertyName);
+                const reason = getJsDocDeprecation(property);
+                if (reason == null) {
+                    return;
+                }
+                if ((0, util_1.typeMatchesSomeSpecifier)(objectType, allow, services.program)) {
+                    return;
+                }
+                context.report({
+                    ...(reason
+                        ? {
+                            messageId: 'deprecatedWithReason',
+                            data: { name: propertyName, reason },
+                        }
+                        : {
+                            messageId: 'deprecated',
+                            data: { name: propertyName },
+                        }),
+                    node: node.property,
+                });
+            }
+        }
         return {
             Identifier: checkIdentifier,
             JSXIdentifier(node) {
@@ -325,6 +357,7 @@ exports.default = (0, util_1.createRule)({
                     checkIdentifier(node);
                 }
             },
+            MemberExpression: checkMemberExpression,
             PrivateIdentifier: checkIdentifier,
             Super: checkIdentifier,
         };

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-duplicate-enum-values.js

@@ -39,10 +39,10 @@ exports.default = (0, util_1.createRule)({
                     }
                     let value;
                     if (isStringLiteral(member.initializer)) {
-                        value = String(member.initializer.value);
+                        value = member.initializer.value;
                     }
                     else if (isNumberLiteral(member.initializer)) {
-                        value = Number(member.initializer.value);
+                        value = member.initializer.value;
                     }
                     else if (isStaticTemplateLiteral(member.initializer)) {
                         value = member.initializer.quasis[0].value.cooked;

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-empty-interface.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAOzD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,kBAAkB,CAAC;;AAExD,wBAmHG"}
+{"version":3,"file":"no-empty-interface.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAOzD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,kBAAkB,CAAC;;AAExD,wBAkHG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-empty-interface.js

@@ -75,9 +75,9 @@ exports.default = (0, util_1.createRule)({
                     const mergedWithClassDeclaration = scope.set
                         .get(node.id.name)
                         ?.defs.some(def => def.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
-                    const isInAmbientDeclaration = !!((0, util_1.isDefinitionFile)(context.filename) &&
+                    const isInAmbientDeclaration = (0, util_1.isDefinitionFile)(context.filename) &&
                         scope.type === scope_manager_1.ScopeType.tsModule &&
-                        scope.block.declare);
+                        scope.block.declare;
                     const useAutoFix = !(isInAmbientDeclaration || mergedWithClassDeclaration);
                     context.report({
                         node: node.id,

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-floating-promises.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-floating-promises.d.ts","sourceRoot":"","sources":["../../src/rules/no-floating-promises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAepD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sBAAsB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAChD,yBAAyB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QACnD,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,0BAA0B,GAC1B,iCAAiC,GACjC,qCAAqC,GACrC,cAAc,CAAC;;AAmBnB,wBAkaG"}
+{"version":3,"file":"no-floating-promises.d.ts","sourceRoot":"","sources":["../../src/rules/no-floating-promises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAmBpD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sBAAsB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAChD,yBAAyB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QACnD,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,0BAA0B,GAC1B,iCAAiC,GACjC,qCAAqC,GACrC,cAAc,CAAC;;AAmBnB,wBAqZG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-floating-promises.js

@@ -37,6 +37,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
+const promiseUtils_1 = require("../util/promiseUtils");
 const messageBase = 'Promises must be awaited, end with a call to .catch, or end with a call to .then with a rejection handler.';
 const messageBaseVoid = 'Promises must be awaited, end with a call to .catch, end with a call to .then with a rejection handler' +
     ' or be explicitly marked as ignored with the `void` operator.';
@@ -256,33 +257,20 @@ exports.default = (0, util_1.createRule)({
             if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
                 // If the outer expression is a call, a `.catch()` or `.then()` with
                 // rejection handler handles the promise.
-                const { callee } = node;
+                const promiseHandlingMethodCall = (0, promiseUtils_1.parseCatchCall)(node, context) ?? (0, promiseUtils_1.parseThenCall)(node, context);
-                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                if (promiseHandlingMethodCall != null) {
-                    const methodName = (0, util_1.getStaticMemberAccessValue)(callee, context);
+                    const onRejected = promiseHandlingMethodCall.onRejected;
-                    const catchRejectionHandler = methodName === 'catch' && node.arguments.length >= 1
+                    if (onRejected != null) {
-                        ? node.arguments[0]
+                        if (isValidRejectionHandler(onRejected)) {
-                        : undefined;
-                    if (catchRejectionHandler) {
-                        if (isValidRejectionHandler(catchRejectionHandler)) {
                             return { isUnhandled: false };
                         }
                         return { isUnhandled: true, nonFunctionHandler: true };
                     }
-                    const thenRejectionHandler = methodName === 'then' && node.arguments.length >= 2
+                    return { isUnhandled: true };
-                        ? node.arguments[1]
+                }
-                        : undefined;
+                const promiseFinallyCall = (0, promiseUtils_1.parseFinallyCall)(node, context);
-                    if (thenRejectionHandler) {
+                if (promiseFinallyCall != null) {
-                        if (isValidRejectionHandler(thenRejectionHandler)) {
+                    return isUnhandledPromise(checker, promiseFinallyCall.object);
-                            return { isUnhandled: false };
-                        }
-                        return { isUnhandled: true, nonFunctionHandler: true };
-                    }
-                    // `x.finally()` is transparent to resolution of the promise, so check `x`.
-                    // ("object" in this context is the `x` in `x.finally()`)
-                    const promiseFinallyObject = methodName === 'finally' ? callee.object : undefined;
-                    if (promiseFinallyObject) {
-                        return isUnhandledPromise(checker, promiseFinallyObject);
-                    }
                 }
                 // All other cases are unhandled.
                 return { isUnhandled: true };
@@ -309,7 +297,7 @@ exports.default = (0, util_1.createRule)({
         function isPromiseArray(node) {
             const type = checker.getTypeAtLocation(node);
             for (const ty of tsutils
-                .unionTypeParts(type)
+                .unionConstituents(type)
                 .map(t => checker.getApparentType(t))) {
                 if (checker.isArrayType(ty)) {
                     const arrayType = checker.getTypeArguments(ty)[0];
@@ -334,7 +322,7 @@ exports.default = (0, util_1.createRule)({
                 return false;
             }
             // Otherwise, we always consider the built-in Promise to be Promise-like...
-            const typeParts = tsutils.unionTypeParts(checker.getApparentType(type));
+            const typeParts = tsutils.unionConstituents(checker.getApparentType(type));
             if (typeParts.some(typePart => (0, util_1.isBuiltinSymbolLike)(services.program, typePart, 'Promise'))) {
                 return true;
             }
@@ -363,7 +351,7 @@ exports.default = (0, util_1.createRule)({
     },
 });
 function hasMatchingSignature(type, matcher) {
-    for (const t of tsutils.unionTypeParts(type)) {
+    for (const t of tsutils.unionConstituents(type)) {
         if (t.getCallSignatures().some(matcher)) {
             return true;
         }
@@ -372,7 +360,7 @@ function hasMatchingSignature(type, matcher) {
 }
 function isFunctionParam(checker, param, node) {
     const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node));
-    for (const t of tsutils.unionTypeParts(type)) {
+    for (const t of tsutils.unionConstituents(type)) {
         if (t.getCallSignatures().length !== 0) {
             return true;
         }

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-meaningless-void-operator.js

@@ -79,7 +79,7 @@ exports.default = (0, util_1.createRule)({
                     ]);
                 };
                 const argType = services.getTypeAtLocation(node.argument);
-                const unionParts = tsutils.unionTypeParts(argType);
+                const unionParts = tsutils.unionConstituents(argType);
                 if (unionParts.every(part => part.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined))) {
                     context.report({
                         node,

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-promises.js

@@ -551,7 +551,7 @@ exports.default = (0, util_1.createRule)({
 });
 function isSometimesThenable(checker, node) {
     const type = checker.getTypeAtLocation(node);
-    for (const subType of tsutils.unionTypeParts(checker.getApparentType(type))) {
+    for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) {
         if (tsutils.isThenableType(checker, node, subType)) {
             return true;
         }
@@ -564,7 +564,7 @@ function isSometimesThenable(checker, node) {
 // branches is thenable.
 function isAlwaysThenable(checker, node) {
     const type = checker.getTypeAtLocation(node);
-    for (const subType of tsutils.unionTypeParts(checker.getApparentType(type))) {
+    for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) {
         const thenProp = subType.getProperty('then');
         // If one of the alternates has no then property, it is not thenable in all
         // cases.
@@ -576,7 +576,7 @@ function isAlwaysThenable(checker, node) {
         // be of the right form to consider it thenable.
         const thenType = checker.getTypeOfSymbolAtLocation(thenProp, node);
         let hasThenableSignature = false;
-        for (const subType of tsutils.unionTypeParts(thenType)) {
+        for (const subType of tsutils.unionConstituents(thenType)) {
             for (const signature of subType.getCallSignatures()) {
                 if (signature.parameters.length !== 0 &&
                     isFunctionParam(checker, signature.parameters[0], node)) {
@@ -602,7 +602,7 @@ function isAlwaysThenable(checker, node) {
 }
 function isFunctionParam(checker, param, node) {
     const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node));
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         if (subType.getCallSignatures().length !== 0) {
             return true;
         }
@@ -641,7 +641,7 @@ function voidFunctionArguments(checker, node) {
     const type = checker.getTypeAtLocation(node.expression);
     // We can't use checker.getResolvedSignature because it prefers an early '() => void' over a later '() => Promise<void>'
     // See https://github.com/microsoft/TypeScript/issues/48077
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         // Standard function calls and `new` have two different types of signatures
         const signatures = ts.isCallExpression(node)
             ? subType.getCallSignatures()
@@ -698,7 +698,7 @@ function anySignatureIsThenableType(checker, node, type) {
  * @returns Whether type is a thenable-returning function.
  */
 function isThenableReturningFunctionType(checker, node, type) {
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         if (anySignatureIsThenableType(checker, node, subType)) {
             return true;
         }
@@ -710,7 +710,7 @@ function isThenableReturningFunctionType(checker, node, type) {
  */
 function isVoidReturningFunctionType(checker, node, type) {
     let hadVoidReturn = false;
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         for (const signature of subType.getCallSignatures()) {
             const returnType = signature.getReturnType();
             // If a certain positional argument accepts both thenable and void returns,
@@ -729,7 +729,7 @@ function isVoidReturningFunctionType(checker, node, type) {
 function returnsThenable(checker, node) {
     const type = checker.getApparentType(checker.getTypeAtLocation(node));
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
         .some(t => anySignatureIsThenableType(checker, node, t));
 }
 function getHeritageTypes(checker, tsNode) {

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-misused-spread.js

@@ -97,7 +97,7 @@ exports.default = (0, util_1.createRule)({
             }
         }
         function getMapSpreadSuggestions(node, type) {
-            const types = tsutils.unionTypeParts(type);
+            const types = tsutils.unionConstituents(type);
             if (types.some(t => !isMap(services.program, t))) {
                 return null;
             }
@@ -208,7 +208,7 @@ exports.default = (0, util_1.createRule)({
 });
 function isIterable(type, checker) {
     return tsutils
-        .typeParts(type)
+        .typeConstituents(type)
         .some(t => !!tsutils.getWellKnownSymbolPropertyOfType(t, 'iterator', checker));
 }
 function isArray(checker, type) {

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-redundant-type-constituents.js

@@ -156,7 +156,7 @@ function describeLiteralTypeNode(typeNode) {
     return 'literal type';
 }
 function isNodeInsideReturnType(node) {
-    return !!(node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+    return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
         (0, util_1.isFunctionOrFunctionType)(node.parent.parent));
 }
 /**
@@ -168,7 +168,7 @@ function unionTypePartsUnlessBoolean(type) {
         tsutils.isFalseLiteralType(type.types[0]) &&
         tsutils.isTrueLiteralType(type.types[1])
         ? [type]
-        : tsutils.unionTypeParts(type);
+        : tsutils.unionConstituents(type);
 }
 exports.default = (0, util_1.createRule)({
     name: 'no-redundant-type-constituents',

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.js

@@ -44,14 +44,14 @@ function isNullishType(type) {
     return tsutils.isTypeFlagSet(type, nullishFlag);
 }
 function isAlwaysNullish(type) {
-    return tsutils.unionTypeParts(type).every(isNullishType);
+    return tsutils.unionConstituents(type).every(isNullishType);
 }
 /**
  * Note that this differs from {@link isNullableType} in that it doesn't consider
  * `any` or `unknown` to be nullable.
  */
 function isPossiblyNullish(type) {
-    return tsutils.unionTypeParts(type).some(isNullishType);
+    return tsutils.unionConstituents(type).some(isNullishType);
 }
 function toStaticValue(type) {
     // type.isLiteral() only covers numbers/bigints and strings, hence the rest of the branches.
@@ -198,13 +198,13 @@ exports.default = (0, util_1.createRule)({
         function nodeIsArrayType(node) {
             const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
             return tsutils
-                .unionTypeParts(nodeType)
+                .unionConstituents(nodeType)
                 .some(part => checker.isArrayType(part));
         }
         function nodeIsTupleType(node) {
             const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
             return tsutils
-                .unionTypeParts(nodeType)
+                .unionConstituents(nodeType)
                 .some(part => checker.isTupleType(part));
         }
         function isArrayIndexExpression(node) {
@@ -223,7 +223,7 @@ exports.default = (0, util_1.createRule)({
         //    `any` or `unknown` or a naked type variable
         function isConditionalAlwaysNecessary(type) {
             return tsutils
-                .unionTypeParts(type)
+                .unionConstituents(type)
                 .some(part => (0, util_1.isTypeAnyType)(part) ||
                 (0, util_1.isTypeUnknownType)(part) ||
                 (0, util_1.isTypeFlagSet)(part, ts.TypeFlags.TypeVariable));

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-unnecessary-template-expression.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-template-expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAmBzD,MAAM,MAAM,SAAS,GAAG,iCAAiC,CAAC;;AAuB1D,wBAmbG"}
+{"version":3,"file":"no-unnecessary-template-expression.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-template-expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAmBzD,MAAM,MAAM,SAAS,GAAG,iCAAiC,CAAC;;AAqB1D,wBAgbG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-template-expression.js

@@ -43,7 +43,7 @@ const evenNumOfBackslashesRegExp = /(?<!(?:[^\\]|^)(?:\\\\)*\\)/;
 // '\\\\$' <- true
 // '\\\\\\$' <- false
 function endsWithUnescapedDollarSign(str) {
-    return new RegExp(`${String(evenNumOfBackslashesRegExp.source)}\\$$`).test(str);
+    return new RegExp(`${evenNumOfBackslashesRegExp.source}\\$$`).test(str);
 }
 exports.default = (0, util_1.createRule)({
     name: 'no-unnecessary-template-expression',
@@ -77,7 +77,7 @@ exports.default = (0, util_1.createRule)({
             return isStringLike(type);
         }
         function isEnumMemberType(type) {
-            return tsutils.typeParts(type).some(t => {
+            return tsutils.typeConstituents(type).some(t => {
                 const symbol = t.getSymbol();
                 return !!(symbol?.valueDeclaration && ts.isEnumMember(symbol.valueDeclaration));
             });
@@ -233,7 +233,7 @@ exports.default = (0, util_1.createRule)({
                         // \\` -> \\\`
                         // \${ -> \${
                         // \\${ -> \\\${
-                        .replaceAll(new RegExp(`${String(evenNumOfBackslashesRegExp.source)}(\`|\\\${)`, 'g'), '\\$1');
+                        .replaceAll(new RegExp(`${evenNumOfBackslashesRegExp.source}(\`|\\\${)`, 'g'), '\\$1');
                     // `...${'...$'}{...`
                     //           ^^^^
                     if (nextCharacterIsOpeningCurlyBrace &&

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-assertion.js

@@ -171,10 +171,10 @@ exports.default = (0, util_1.createRule)({
                 (0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.Undefined) &&
                 tsutils.isCompilerOptionEnabled(compilerOptions, 'exactOptionalPropertyTypes')) {
                 const uncastParts = tsutils
-                    .unionTypeParts(uncast)
+                    .unionConstituents(uncast)
                     .filter(part => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
                 const castParts = tsutils
-                    .unionTypeParts(cast)
+                    .unionConstituents(cast)
                     .filter(part => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
                 if (uncastParts.length !== castParts.length) {
                     return false;

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.d.ts

@@ -0,0 +1,4 @@
+type MessageIds = 'suggestRemove' | 'suggestSatisfies' | 'unnecessaryTypeConversion';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=no-unnecessary-type-conversion.d.ts.map

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unnecessary-type-conversion.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-type-conversion.ts"],"names":[],"mappings":"AAgBA,KAAK,UAAU,GACX,eAAe,GACf,kBAAkB,GAClB,2BAA2B,CAAC;;AAEhC,wBAqVG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-conversion.js

@@ -0,0 +1,306 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-unnecessary-type-conversion',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow conversion idioms when they do not change the type or value of the expression',
+            requiresTypeChecking: true,
+        },
+        hasSuggestions: true,
+        messages: {
+            suggestRemove: 'Remove the type conversion.',
+            suggestSatisfies: 'Instead, assert that the value satisfies the {{type}} type.',
+            unnecessaryTypeConversion: '{{violation}} does not change the type or value of the {{type}}.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        function doesUnderlyingTypeMatchFlag(type, typeFlag) {
+            return tsutils
+                .unionConstituents(type)
+                .every(t => (0, util_1.isTypeFlagSet)(t, typeFlag));
+        }
+        const services = (0, util_1.getParserServices)(context);
+        function handleUnaryOperator(node, typeFlag, typeString, violation, isDoubleOperator) {
+            const outerNode = isDoubleOperator ? node.parent : node;
+            const type = services.getTypeAtLocation(node.argument);
+            if (doesUnderlyingTypeMatchFlag(type, typeFlag)) {
+                const wrappingFixerParams = {
+                    node: outerNode,
+                    innerNode: [node.argument],
+                    sourceCode: context.sourceCode,
+                };
+                context.report({
+                    loc: {
+                        start: outerNode.loc.start,
+                        end: {
+                            column: node.loc.start.column + 1,
+                            line: node.loc.start.line,
+                        },
+                    },
+                    messageId: 'unnecessaryTypeConversion',
+                    data: { type: typeString, violation },
+                    suggest: [
+                        {
+                            messageId: 'suggestRemove',
+                            fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                        },
+                        {
+                            messageId: 'suggestSatisfies',
+                            data: { type: typeString },
+                            fix: (0, util_1.getWrappingFixer)({
+                                ...wrappingFixerParams,
+                                wrap: expr => `${expr} satisfies ${typeString}`,
+                            }),
+                        },
+                    ],
+                });
+            }
+        }
+        return {
+            'AssignmentExpression[operator = "+="]'(node) {
+                if (node.right.type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.right.value === '' &&
+                    doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.left), ts.TypeFlags.StringLike)) {
+                    const wrappingFixerParams = {
+                        node,
+                        innerNode: [node.left],
+                        sourceCode: context.sourceCode,
+                    };
+                    context.report({
+                        node,
+                        messageId: 'unnecessaryTypeConversion',
+                        data: {
+                            type: 'string',
+                            violation: "Concatenating a string with ''",
+                        },
+                        suggest: [
+                            {
+                                messageId: 'suggestRemove',
+                                fix: node.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement
+                                    ? (fixer) => [
+                                        fixer.removeRange([
+                                            node.parent.range[0],
+                                            node.parent.range[1],
+                                        ]),
+                                    ]
+                                    : (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                            },
+                            {
+                                messageId: 'suggestSatisfies',
+                                data: { type: 'string' },
+                                fix: (0, util_1.getWrappingFixer)({
+                                    ...wrappingFixerParams,
+                                    wrap: expr => `${expr} satisfies string`,
+                                }),
+                            },
+                        ],
+                    });
+                }
+            },
+            'BinaryExpression[operator = "+"]'(node) {
+                if (node.right.type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.right.value === '' &&
+                    doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.left), ts.TypeFlags.StringLike)) {
+                    const wrappingFixerParams = {
+                        node,
+                        innerNode: [node.left],
+                        sourceCode: context.sourceCode,
+                    };
+                    context.report({
+                        loc: {
+                            start: node.left.loc.end,
+                            end: node.loc.end,
+                        },
+                        messageId: 'unnecessaryTypeConversion',
+                        data: {
+                            type: 'string',
+                            violation: "Concatenating a string with ''",
+                        },
+                        suggest: [
+                            {
+                                messageId: 'suggestRemove',
+                                fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                            },
+                            {
+                                messageId: 'suggestSatisfies',
+                                data: { type: 'string' },
+                                fix: (0, util_1.getWrappingFixer)({
+                                    ...wrappingFixerParams,
+                                    wrap: expr => `${expr} satisfies string`,
+                                }),
+                            },
+                        ],
+                    });
+                }
+                else if (node.left.type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.left.value === '' &&
+                    doesUnderlyingTypeMatchFlag(services.getTypeAtLocation(node.right), ts.TypeFlags.StringLike)) {
+                    const wrappingFixerParams = {
+                        node,
+                        innerNode: [node.right],
+                        sourceCode: context.sourceCode,
+                    };
+                    context.report({
+                        loc: {
+                            start: node.loc.start,
+                            end: node.right.loc.start,
+                        },
+                        messageId: 'unnecessaryTypeConversion',
+                        data: {
+                            type: 'string',
+                            violation: "Concatenating '' with a string",
+                        },
+                        suggest: [
+                            {
+                                messageId: 'suggestRemove',
+                                fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                            },
+                            {
+                                messageId: 'suggestSatisfies',
+                                data: { type: 'string' },
+                                fix: (0, util_1.getWrappingFixer)({
+                                    ...wrappingFixerParams,
+                                    wrap: expr => `${expr} satisfies string`,
+                                }),
+                            },
+                        ],
+                    });
+                }
+            },
+            CallExpression(node) {
+                const nodeCallee = node.callee;
+                const builtInTypeFlags = {
+                    BigInt: ts.TypeFlags.BigIntLike,
+                    Boolean: ts.TypeFlags.BooleanLike,
+                    Number: ts.TypeFlags.NumberLike,
+                    String: ts.TypeFlags.StringLike,
+                };
+                if (nodeCallee.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !(nodeCallee.name in builtInTypeFlags)) {
+                    return;
+                }
+                const typeFlag = builtInTypeFlags[nodeCallee.name];
+                const scope = context.sourceCode.getScope(node);
+                const variable = scope.set.get(nodeCallee.name);
+                if (!!variable?.defs.length ||
+                    !doesUnderlyingTypeMatchFlag((0, util_1.getConstrainedTypeAtLocation)(services, node.arguments[0]), typeFlag)) {
+                    return;
+                }
+                const wrappingFixerParams = {
+                    node,
+                    innerNode: [node.arguments[0]],
+                    sourceCode: context.sourceCode,
+                };
+                const typeString = nodeCallee.name.toLowerCase();
+                context.report({
+                    node: nodeCallee,
+                    messageId: 'unnecessaryTypeConversion',
+                    data: {
+                        type: nodeCallee.name.toLowerCase(),
+                        violation: `Passing a ${typeString} to ${nodeCallee.name}()`,
+                    },
+                    suggest: [
+                        {
+                            messageId: 'suggestRemove',
+                            fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                        },
+                        {
+                            messageId: 'suggestSatisfies',
+                            data: { type: typeString },
+                            fix: (0, util_1.getWrappingFixer)({
+                                ...wrappingFixerParams,
+                                wrap: expr => `${expr} satisfies ${typeString}`,
+                            }),
+                        },
+                    ],
+                });
+            },
+            'CallExpression > MemberExpression.callee > Identifier[name = "toString"].property'(node) {
+                const memberExpr = node.parent;
+                const type = (0, util_1.getConstrainedTypeAtLocation)(services, memberExpr.object);
+                if (doesUnderlyingTypeMatchFlag(type, ts.TypeFlags.StringLike)) {
+                    const wrappingFixerParams = {
+                        node: memberExpr.parent,
+                        innerNode: [memberExpr.object],
+                        sourceCode: context.sourceCode,
+                    };
+                    context.report({
+                        loc: {
+                            start: memberExpr.property.loc.start,
+                            end: memberExpr.parent.loc.end,
+                        },
+                        messageId: 'unnecessaryTypeConversion',
+                        data: {
+                            type: 'string',
+                            violation: "Calling a string's .toString() method",
+                        },
+                        suggest: [
+                            {
+                                messageId: 'suggestRemove',
+                                fix: (0, util_1.getWrappingFixer)(wrappingFixerParams),
+                            },
+                            {
+                                messageId: 'suggestSatisfies',
+                                data: { type: 'string' },
+                                fix: (0, util_1.getWrappingFixer)({
+                                    ...wrappingFixerParams,
+                                    wrap: expr => `${expr} satisfies string`,
+                                }),
+                            },
+                        ],
+                    });
+                }
+            },
+            'UnaryExpression[operator = "!"] > UnaryExpression[operator = "!"]'(node) {
+                handleUnaryOperator(node, ts.TypeFlags.BooleanLike, 'boolean', 'Using !! on a boolean', true);
+            },
+            'UnaryExpression[operator = "+"]'(node) {
+                handleUnaryOperator(node, ts.TypeFlags.NumberLike, 'number', 'Using the unary + operator on a number', false);
+            },
+            'UnaryExpression[operator = "~"] > UnaryExpression[operator = "~"]'(node) {
+                handleUnaryOperator(node, ts.TypeFlags.NumberLike, 'number', 'Using ~~ on a number', true);
+            },
+        };
+    },
+});

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-unnecessary-type-parameters.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-type-parameters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;;AAoBnE,wBAqLG"}
+{"version":3,"file":"no-unnecessary-type-parameters.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-type-parameters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;;AAqBnE,wBA0MG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-type-parameters.js

@@ -101,7 +101,28 @@ exports.default = (0, util_1.createRule)({
                                 for (const reference of smTypeParameterVariable.references) {
                                     if (reference.isTypeReference) {
                                         const referenceNode = reference.identifier;
-                                        yield fixer.replaceText(referenceNode, constraintText);
+                                        const isComplexType = constraint?.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+                                            constraint?.type === utils_1.AST_NODE_TYPES.TSIntersectionType ||
+                                            constraint?.type === utils_1.AST_NODE_TYPES.TSConditionalType;
+                                        const hasMatchingAncestorType = [
+                                            utils_1.AST_NODE_TYPES.TSArrayType,
+                                            utils_1.AST_NODE_TYPES.TSIndexedAccessType,
+                                            utils_1.AST_NODE_TYPES.TSIntersectionType,
+                                            utils_1.AST_NODE_TYPES.TSUnionType,
+                                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                        ].some(type => referenceNode.parent.parent.type === type);
+                                        if (isComplexType && hasMatchingAncestorType) {
+                                            const fixResult = (0, util_1.getWrappingFixer)({
+                                                node: referenceNode,
+                                                innerNode: constraint,
+                                                sourceCode: context.sourceCode,
+                                                wrap: constraintNode => constraintNode,
+                                            })(fixer);
+                                            yield fixResult;
+                                        }
+                                        else {
+                                            yield fixer.replaceText(referenceNode, constraintText);
+                                        }
                                     }
                                 }
                                 // ...and remove the type parameter itself from the declaration.

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-assignment.js

@@ -168,7 +168,7 @@ exports.default = (0, util_1.createRule)({
                 }
                 else if (receiverProperty.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
                     receiverProperty.key.quasis.length === 1) {
-                    key = String(receiverProperty.key.quasis[0].value.cooked);
+                    key = receiverProperty.key.quasis[0].value.cooked;
                 }
                 else {
                     // can't figure out the name, so skip it

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-enum-comparison.js

@@ -46,13 +46,13 @@ function typeViolates(leftTypeParts, rightType) {
         (leftEnumValueTypes.has(ts.TypeFlags.String) && isStringLike(rightType)));
 }
 function isNumberLike(type) {
-    const typeParts = tsutils.intersectionTypeParts(type);
+    const typeParts = tsutils.intersectionConstituents(type);
     return typeParts.some(typePart => {
         return tsutils.isTypeFlagSet(typePart, ts.TypeFlags.Number | ts.TypeFlags.NumberLike);
     });
 }
 function isStringLike(type) {
-    const typeParts = tsutils.intersectionTypeParts(type);
+    const typeParts = tsutils.intersectionConstituents(type);
     return typeParts.some(typePart => {
         return tsutils.isTypeFlagSet(typePart, ts.TypeFlags.String | ts.TypeFlags.StringLike);
     });
@@ -116,8 +116,8 @@ exports.default = (0, util_1.createRule)({
             // declare const something: Fruit | Vegetable;
             // something === Fruit.Apple;
             // ```
-            const leftTypeParts = tsutils.unionTypeParts(leftType);
+            const leftTypeParts = tsutils.unionConstituents(leftType);
-            const rightTypeParts = tsutils.unionTypeParts(rightType);
+            const rightTypeParts = tsutils.unionConstituents(rightType);
             // If a type exists in both sides, we consider this comparison safe:
             //
             // ```ts

node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unsafe-unary-minus.js

@@ -61,7 +61,7 @@ exports.default = util.createRule({
                 const argType = util.getConstrainedTypeAtLocation(services, node.argument);
                 const checker = services.program.getTypeChecker();
                 if (tsutils
-                    .unionTypeParts(argType)
+                    .unionConstituents(argType)
                     .some(type => !tsutils.isTypeFlagSet(type, ts.TypeFlags.Any |
                     ts.TypeFlags.Never |
                     ts.TypeFlags.BigIntLike |

node_modules/@typescript-eslint/eslint-plugin/dist/rules/non-nullable-type-assertion-style.js

@@ -60,7 +60,7 @@ exports.default = (0, util_1.createRule)({
             if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
                 return undefined;
             }
-            return tsutils.unionTypeParts(type);
+            return tsutils.unionConstituents(type);
         };
         const couldBeNullish = (type) => {
             if (type.flags & ts.TypeFlags.TypeParameter) {

node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.d.ts

@@ -3,6 +3,7 @@ export type MessageIds = 'object' | 'undef';
 export type Options = [
     {
         allow?: TypeOrValueSpecifier[];
+        allowRethrowing?: boolean;
         allowThrowingAny?: boolean;
         allowThrowingUnknown?: boolean;
     }

node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"only-throw-error.d.ts","sourceRoot":"","sources":["../../src/rules/only-throw-error.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAYpD,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE5C,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAC/B,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC;CACF,CAAC;;AAEF,wBAuFG"}
+{"version":3,"file":"only-throw-error.d.ts","sourceRoot":"","sources":["../../src/rules/only-throw-error.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAepD,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE5C,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC;CACF,CAAC;;AAEF,wBA4JG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/only-throw-error.js

@@ -34,8 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
+const ts_api_utils_1 = require("ts-api-utils");
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
+const promiseUtils_1 = require("../util/promiseUtils");
 exports.default = (0, util_1.createRule)({
     name: 'only-throw-error',
     meta: {
@@ -59,6 +61,10 @@ exports.default = (0, util_1.createRule)({
                         ...util_1.typeOrValueSpecifiersSchema,
                         description: 'Type specifiers that can be thrown.',
                     },
+                    allowRethrowing: {
+                        type: 'boolean',
+                        description: 'Whether to allow rethrowing caught values that are not `Error` objects.',
+                    },
                     allowThrowingAny: {
                         type: 'boolean',
                         description: 'Whether to always allow throwing values typed as `any`.',
@@ -74,6 +80,7 @@ exports.default = (0, util_1.createRule)({
     defaultOptions: [
         {
             allow: [],
+            allowRethrowing: true,
             allowThrowingAny: true,
             allowThrowingUnknown: true,
         },
@@ -81,11 +88,51 @@ exports.default = (0, util_1.createRule)({
     create(context, [options]) {
         const services = (0, util_1.getParserServices)(context);
         const allow = options.allow;
+        function isRethrownError(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            const scope = context.sourceCode.getScope(node);
+            const smVariable = (0, util_1.nullThrows)((0, util_1.findVariable)(scope, node), `Variable ${node.name} should exist in scope manager`);
+            const variableDefinitions = smVariable.defs.filter(def => def.isVariableDefinition);
+            if (variableDefinitions.length !== 1) {
+                return false;
+            }
+            const def = smVariable.defs[0];
+            // try { /* ... */ } catch (x) { throw x; }
+            if (def.node.type === utils_1.AST_NODE_TYPES.CatchClause) {
+                return true;
+            }
+            // promise.catch(x => { throw x; })
+            // promise.then(onFulfilled, x => { throw x; })
+            if (def.node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                def.node.params.length >= 1 &&
+                def.node.params[0] === def.name &&
+                def.node.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                const callExpression = def.node.parent;
+                const parsedPromiseHandlingCall = (0, promiseUtils_1.parseCatchCall)(callExpression, context) ??
+                    (0, promiseUtils_1.parseThenCall)(callExpression, context);
+                if (parsedPromiseHandlingCall != null) {
+                    const { object, onRejected } = parsedPromiseHandlingCall;
+                    if (onRejected === def.node) {
+                        const tsObjectNode = services.esTreeNodeToTSNodeMap.get(object);
+                        // make sure we're actually dealing with a promise
+                        if ((0, ts_api_utils_1.isThenableType)(services.program.getTypeChecker(), tsObjectNode)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
         function checkThrowArgument(node) {
             if (node.type === utils_1.AST_NODE_TYPES.AwaitExpression ||
                 node.type === utils_1.AST_NODE_TYPES.YieldExpression) {
                 return;
             }
+            if (options.allowRethrowing && isRethrownError(node)) {
+                return;
+            }
             const type = services.getTypeAtLocation(node);
             if ((0, util_1.typeMatchesSomeSpecifier)(type, allow, services.program)) {
                 return;

node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-find.js

@@ -109,7 +109,7 @@ exports.default = (0, util_1.createRule)({
          */
         function isArrayish(type) {
             let isAtLeastOneArrayishComponent = false;
-            for (const unionPart of tsutils.unionTypeParts(type)) {
+            for (const unionPart of tsutils.unionConstituents(type)) {
                 if (tsutils.isIntrinsicNullType(unionPart) ||
                     tsutils.isIntrinsicUndefinedType(unionPart)) {
                     continue;
@@ -117,7 +117,7 @@ exports.default = (0, util_1.createRule)({
                 // apparently checker.isArrayType(T[] & S[]) => false.
                 // so we need to check the intersection parts individually.
                 const isArrayOrIntersectionThereof = tsutils
-                    .intersectionTypeParts(unionPart)
+                    .intersectionConstituents(unionPart)
                     .every(intersectionPart => checker.isArrayType(intersectionPart) ||
                     checker.isTupleType(intersectionPart));
                 if (!isArrayOrIntersectionThereof) {

node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-nullish-coalescing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-nullish-coalescing.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-nullish-coalescing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAqCnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,qBAAqB,CAAC,EAAE,OAAO,CAAC;QAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;QACjC,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,6BAA6B,CAAC,EAAE,OAAO,CAAC;QACxC,gBAAgB,CAAC,EACb;YACE,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,OAAO,CAAC,EAAE,OAAO,CAAC;YAClB,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,MAAM,CAAC,EAAE,OAAO,CAAC;SAClB,GACD,IAAI,CAAC;QACT,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,mBAAmB,GACnB,6BAA6B,GAC7B,qBAAqB,GACrB,0BAA0B,GAC1B,gBAAgB,CAAC;;AAErB,wBA8jBG"}
+{"version":3,"file":"prefer-nullish-coalescing.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-nullish-coalescing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAyCnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,qBAAqB,CAAC,EAAE,OAAO,CAAC;QAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;QACjC,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,6BAA6B,CAAC,EAAE,OAAO,CAAC;QACxC,gBAAgB,CAAC,EACb;YACE,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,OAAO,CAAC,EAAE,OAAO,CAAC;YAClB,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,MAAM,CAAC,EAAE,OAAO,CAAC;SAClB,GACD,IAAI,CAAC;QACT,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,mBAAmB,GACnB,6BAA6B,GAC7B,qBAAqB,GACrB,0BAA0B,GAC1B,gBAAgB,CAAC;;AAErB,wBA+kBG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-nullish-coalescing.js

@@ -37,6 +37,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
+const getWrappedCode_1 = require("../util/getWrappedCode");
 const isMemberAccessLike = (0, util_1.isNodeOfTypes)([
     utils_1.AST_NODE_TYPES.ChainExpression,
     utils_1.AST_NODE_TYPES.Identifier,
@@ -194,9 +195,9 @@ exports.default = (0, util_1.createRule)({
                 return false;
             }
             if (tsutils
-                .typeParts(type)
+                .typeConstituents(type)
                 .some(t => tsutils
-                .intersectionTypeParts(t)
+                .intersectionConstituents(t)
                 .some(t => tsutils.isTypeFlagSet(t, ignorableFlags)))) {
                 return false;
             }
@@ -354,7 +355,8 @@ exports.default = (0, util_1.createRule)({
                 if (operator == null) {
                     return;
                 }
-                const nullishCoalescingParams = getNullishCoalescingParams(node, getBranchNodes(node, operator).nonNullishBranch, nodesInsideTestExpression, operator);
+                const { nonNullishBranch, nullishBranch } = getBranchNodes(node, operator);
+                const nullishCoalescingParams = getNullishCoalescingParams(node, nonNullishBranch, nodesInsideTestExpression, operator);
                 if (nullishCoalescingParams.isFixable) {
                     context.report({
                         node,
@@ -366,7 +368,11 @@ exports.default = (0, util_1.createRule)({
                                 messageId: 'suggestNullish',
                                 data: { equals: '' },
                                 fix(fixer) {
-                                    return fixer.replaceText(node, `${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingParams.nullishCoalescingLeftNode)} ?? ${(0, util_1.getTextWithParentheses)(context.sourceCode, getBranchNodes(node, operator).nullishBranch)}`);
+                                    const nullishBranchText = (0, util_1.getTextWithParentheses)(context.sourceCode, nullishBranch);
+                                    const rightOperandReplacement = (0, util_1.isParenthesized)(nullishBranch, context.sourceCode)
+                                        ? nullishBranchText
+                                        : (0, getWrappedCode_1.getWrappedCode)(nullishBranchText, (0, util_1.getOperatorPrecedenceForNode)(nullishBranch), util_1.OperatorPrecedence.Coalesce);
+                                    return fixer.replaceText(node, `${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingParams.nullishCoalescingLeftNode)} ?? ${rightOperandReplacement}`);
                                 },
                             },
                         ],

node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/analyzeChain.js

@@ -43,7 +43,7 @@ const compareNodes_1 = require("./compareNodes");
 const gatherLogicalOperands_1 = require("./gatherLogicalOperands");
 function includesType(parserServices, node, typeFlagIn) {
     const typeFlag = typeFlagIn | ts.TypeFlags.Any | ts.TypeFlags.Unknown;
-    const types = (0, ts_api_utils_1.unionTypeParts)(parserServices.getTypeAtLocation(node));
+    const types = (0, ts_api_utils_1.unionConstituents)(parserServices.getTypeAtLocation(node));
     for (const type of types) {
         if ((0, util_1.isTypeFlagSet)(type, typeFlag)) {
             return true;

node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.js

@@ -39,7 +39,7 @@ const ts_api_utils_1 = require("ts-api-utils");
 const ts = __importStar(require("typescript"));
 function checkNullishAndReport(context, parserServices, { requireNullish }, maybeNullishNodes, descriptor) {
     if (!requireNullish ||
-        maybeNullishNodes.some(node => (0, ts_api_utils_1.unionTypeParts)(parserServices.getTypeAtLocation(node)).some(t => (0, type_utils_1.isTypeFlagSet)(t, ts.TypeFlags.Null | ts.TypeFlags.Undefined)))) {
+        maybeNullishNodes.some(node => (0, ts_api_utils_1.unionConstituents)(parserServices.getTypeAtLocation(node)).some(t => (0, type_utils_1.isTypeFlagSet)(t, ts.TypeFlags.Null | ts.TypeFlags.Undefined)))) {
         context.report(descriptor);
     }
 }

node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.js

@@ -72,7 +72,7 @@ var NullishComparisonType;
 const NULLISH_FLAGS = ts.TypeFlags.Null | ts.TypeFlags.Undefined;
 function isValidFalseBooleanCheckType(node, disallowFalseyLiteral, parserServices, options) {
     const type = parserServices.getTypeAtLocation(node);
-    const types = (0, ts_api_utils_1.unionTypeParts)(type);
+    const types = (0, ts_api_utils_1.unionConstituents)(type);
     if (disallowFalseyLiteral &&
         /*
         ```

node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-reduce-type-parameter.js

@@ -56,9 +56,9 @@ exports.default = (0, util_1.createRule)({
         const checker = services.program.getTypeChecker();
         function isArrayType(type) {
             return tsutils
-                .unionTypeParts(type)
+                .unionConstituents(type)
                 .every(unionPart => tsutils
-                .intersectionTypeParts(unionPart)
+                .intersectionConstituents(unionPart)
                 .every(t => checker.isArrayType(t) || checker.isTupleType(t)));
         }
         return {

node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-regexp-exec.js

@@ -147,7 +147,7 @@ exports.default = (0, util_1.createRule)({
                     });
                 }
                 const argumentType = services.getTypeAtLocation(argumentNode);
-                const argumentTypes = collectArgumentTypes(tsutils.unionTypeParts(argumentType));
+                const argumentTypes = collectArgumentTypes(tsutils.unionConstituents(argumentType));
                 switch (argumentTypes) {
                     case ArgumentType.RegExp:
                         return context.report({

node_modules/@typescript-eslint/eslint-plugin/dist/rules/prefer-return-this-type.js

@@ -73,7 +73,7 @@ exports.default = (0, util_1.createRule)({
         }
         function isThisSpecifiedInParameters(originalFunc) {
             const firstArg = originalFunc.params.at(0);
-            return !!(firstArg?.type === utils_1.AST_NODE_TYPES.Identifier && firstArg.name === 'this');
+            return (firstArg?.type === utils_1.AST_NODE_TYPES.Identifier && firstArg.name === 'this');
         }
         function isFunctionReturningThis(originalFunc, originalClass) {
             if (isThisSpecifiedInParameters(originalFunc)) {

node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-plus-operands.js

@@ -156,7 +156,7 @@ exports.default = (0, util_1.createRule)({
                     continue;
                 }
                 // RegExps also contain ts.TypeFlags.Any & ts.TypeFlags.Object
-                for (const subBaseType of tsutils.unionTypeParts(baseType)) {
+                for (const subBaseType of tsutils.unionConstituents(baseType)) {
                     const typeName = (0, util_1.getTypeName)(typeChecker, subBaseType);
                     if (typeName === 'RegExp'
                         ? !allowRegExp ||
@@ -221,11 +221,11 @@ exports.default = (0, util_1.createRule)({
 });
 function isDeeplyObjectType(type) {
     return type.isIntersection()
-        ? tsutils.intersectionTypeParts(type).every(tsutils.isObjectType)
+        ? tsutils.intersectionConstituents(type).every(tsutils.isObjectType)
-        : tsutils.unionTypeParts(type).every(tsutils.isObjectType);
+        : tsutils.unionConstituents(type).every(tsutils.isObjectType);
 }
 function isTypeFlagSetInUnion(type, flag) {
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
         .some(subType => tsutils.isTypeFlagSet(subType, flag));
 }

node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strict-boolean-expressions.d.ts","sourceRoot":"","sources":["../../src/rules/strict-boolean-expressions.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;CACF,CAAC;AAEF,KAAK,uBAAuB,GACxB,mBAAmB,GACnB,+BAA+B,GAC/B,4BAA4B,GAC5B,8BAA8B,GAC9B,8BAA8B,GAC9B,8BAA8B,GAC9B,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,CAAC;AAE3B,MAAM,MAAM,SAAS,GACjB,yBAAyB,GACzB,uCAAuC,GACvC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,wBAAwB,GACxB,4BAA4B,GAC5B,iCAAiC,GACjC,yBAAyB,GACzB,yBAAyB,GACzB,gCAAgC,GAChC,0BAA0B,GAC1B,yBAAyB,GACzB,2BAA2B,GAC3B,mBAAmB,GACnB,wBAAwB,GACxB,uBAAuB,CAAC;;AAE5B,wBAm/BG"}
+{"version":3,"file":"strict-boolean-expressions.d.ts","sourceRoot":"","sources":["../../src/rules/strict-boolean-expressions.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;CACF,CAAC;AAEF,KAAK,uBAAuB,GACxB,mBAAmB,GACnB,+BAA+B,GAC/B,4BAA4B,GAC5B,8BAA8B,GAC9B,8BAA8B,GAC9B,8BAA8B,GAC9B,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,CAAC;AAE3B,MAAM,MAAM,SAAS,GACjB,yBAAyB,GACzB,uCAAuC,GACvC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,wBAAwB,GACxB,4BAA4B,GAC5B,iCAAiC,GACjC,yBAAyB,GACzB,yBAAyB,GACzB,gCAAgC,GAChC,0BAA0B,GAC1B,yBAAyB,GACzB,2BAA2B,GAC3B,mBAAmB,GACnB,wBAAwB,GACxB,uBAAuB,CAAC;;AAE5B,wBAq/BG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.js

@@ -237,7 +237,7 @@ exports.default = (0, util_1.createRule)({
                 return type;
             });
             const flattenTypes = [
-                ...new Set(returnTypes.flatMap(type => tsutils.unionTypeParts(type))),
+                ...new Set(returnTypes.flatMap(type => tsutils.unionConstituents(type))),
             ];
             const types = inspectVariantTypes(flattenTypes);
             const reportType = determineReportType(types);
@@ -774,7 +774,7 @@ exports.default = (0, util_1.createRule)({
          */
         function checkNode(node) {
             const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
-            const types = inspectVariantTypes(tsutils.unionTypeParts(type));
+            const types = inspectVariantTypes(tsutils.unionConstituents(type));
             const reportType = determineReportType(types);
             if (reportType != null) {
                 context.report({
@@ -799,7 +799,7 @@ exports.default = (0, util_1.createRule)({
             // If incoming type is either "true" or "false", there will be one type
             // object with intrinsicName set accordingly
             // If incoming type is boolean, there will be two type objects with
-            // intrinsicName set "true" and "false" each because of ts-api-utils.unionTypeParts()
+            // intrinsicName set "true" and "false" each because of ts-api-utils.unionConstituents()
             if (booleans.length === 1) {
                 variantTypes.add(tsutils.isTrueLiteralType(booleans[0]) ? 'truthy boolean' : 'boolean');
             }

node_modules/@typescript-eslint/eslint-plugin/dist/rules/switch-exhaustiveness-check.js

@@ -122,8 +122,8 @@ exports.default = (0, util_1.createRule)({
                 caseTypes.add(caseType);
             }
             const missingLiteralBranchTypes = [];
-            for (const unionPart of tsutils.unionTypeParts(discriminantType)) {
+            for (const unionPart of tsutils.unionConstituents(discriminantType)) {
-                for (const intersectionPart of tsutils.intersectionTypeParts(unionPart)) {
+                for (const intersectionPart of tsutils.intersectionConstituents(unionPart)) {
                     if (caseTypes.has(intersectionPart) ||
                         !isTypeLiteralLikeType(intersectionPart)) {
                         continue;
@@ -284,8 +284,8 @@ function isTypeLiteralLikeType(type) {
  */
 function doesTypeContainNonLiteralType(type) {
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
         .some(type => tsutils
-        .intersectionTypeParts(type)
+        .intersectionConstituents(type)
         .every(subType => !isTypeLiteralLikeType(subType)));
 }

node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unbound-method.d.ts","sourceRoot":"","sources":["../../src/rules/unbound-method.ts"],"names":[],"mappings":"AAkBA,UAAU,MAAM;IACd,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,8BAA8B,CAAC;;AAiFpE,wBA0KG"}
+{"version":3,"file":"unbound-method.d.ts","sourceRoot":"","sources":["../../src/rules/unbound-method.ts"],"names":[],"mappings":"AAkBA,UAAU,MAAM;IACd,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,8BAA8B,CAAC;;AAiFpE,wBA4KG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/unbound-method.js

@@ -215,8 +215,8 @@ exports.default = (0, util_1.createRule)({
                         }
                     }
                     for (const intersectionPart of tsutils
-                        .unionTypeParts(services.getTypeAtLocation(node))
+                        .unionConstituents(services.getTypeAtLocation(node))
-                        .flatMap(unionPart => tsutils.intersectionTypeParts(unionPart))) {
+                        .flatMap(unionPart => tsutils.intersectionConstituents(unionPart))) {
                         const reported = checkIfMethodAndReport(property.key, intersectionPart.getProperty(property.key.name));
                         if (reported) {
                             break;

node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unified-signatures.d.ts","sourceRoot":"","sources":["../../src/rules/unified-signatures.ts"],"names":[],"mappings":"AAuDA,MAAM,MAAM,UAAU,GAClB,uBAAuB,GACvB,yBAAyB,GACzB,2BAA2B,CAAC;AAEhC,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,gCAAgC,CAAC,EAAE,OAAO,CAAC;QAC3C,iCAAiC,CAAC,EAAE,OAAO,CAAC;KAC7C;CACF,CAAC;;AAEF,wBAyiBG"}
+{"version":3,"file":"unified-signatures.d.ts","sourceRoot":"","sources":["../../src/rules/unified-signatures.ts"],"names":[],"mappings":"AAuDA,MAAM,MAAM,UAAU,GAClB,uBAAuB,GACvB,yBAAyB,GACzB,2BAA2B,CAAC;AAEhC,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,gCAAgC,CAAC,EAAE,OAAO,CAAC;QAC3C,iCAAiC,CAAC,EAAE,OAAO,CAAC;KAC7C;CACF,CAAC;;AAEF,wBA8kBG"}

node_modules/@typescript-eslint/eslint-plugin/dist/rules/unified-signatures.js

@@ -147,6 +147,12 @@ exports.default = (0, util_1.createRule)({
         }
         /** Detect `a(x: number, y: number, z: number)` and `a(x: number, y: string, z: number)`. */
         function signaturesDifferBySingleParameter(types1, types2) {
+            const firstParam1 = types1[0];
+            const firstParam2 = types2[0];
+            // exempt signatures with `this: void` from the rule
+            if (isThisVoidParam(firstParam1) || isThisVoidParam(firstParam2)) {
+                return undefined;
+            }
             const index = getIndexOfFirstDifference(types1, types2, parametersAreEqual);
             if (index == null) {
                 return undefined;
@@ -164,6 +170,16 @@ exports.default = (0, util_1.createRule)({
                 ? { kind: 'single-parameter-difference', p0: a, p1: b }
                 : undefined;
         }
+        function isThisParam(param) {
+            return (param != null &&
+                param.type === utils_1.AST_NODE_TYPES.Identifier &&
+                param.name === 'this');
+        }
+        function isThisVoidParam(param) {
+            return (isThisParam(param) &&
+                param.typeAnnotation?.typeAnnotation.type ===
+                    utils_1.AST_NODE_TYPES.TSVoidKeyword);
+        }
         /**
          * Detect `a(): void` and `a(x: number): void`.
          * Returns the parameter declaration (`x: number` in this example) that should be optional/rest, and overload it's a part of.
@@ -175,6 +191,17 @@ exports.default = (0, util_1.createRule)({
             const longer = sig1.length < sig2.length ? sig2 : sig1;
             const shorter = sig1.length < sig2.length ? sig1 : sig2;
             const shorterSig = sig1.length < sig2.length ? a : b;
+            const firstParam1 = sig1.at(0);
+            const firstParam2 = sig2.at(0);
+            // If one signature has explicit this type and another doesn't, they can't
+            // be unified.
+            if (isThisParam(firstParam1) !== isThisParam(firstParam2)) {
+                return undefined;
+            }
+            // exempt signatures with `this: void` from the rule
+            if (isThisVoidParam(firstParam1) || isThisVoidParam(firstParam2)) {
+                return undefined;
+            }
             // If one is has 2+ parameters more than the other, they must all be optional/rest.
             // Differ by optional parameters: f() and f(x), f() and f(x, ?y, ...z)
             // Not allowed: f() and f(x, y)

node_modules/@typescript-eslint/eslint-plugin/dist/rules/use-unknown-in-catch-callback-variable.js

@@ -63,7 +63,7 @@ exports.default = (0, util_1.createRule)({
         const { esTreeNodeToTSNodeMap, program } = (0, util_1.getParserServices)(context);
         const checker = program.getTypeChecker();
         function isFlaggableHandlerType(type) {
-            for (const unionPart of tsutils.unionTypeParts(type)) {
+            for (const unionPart of tsutils.unionConstituents(type)) {
                 const callSignatures = tsutils.getCallSignaturesOfType(unionPart);
                 if (callSignatures.length === 0) {
                     // Ignore any non-function components to the type. Those are not this rule's problem.

node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.d.ts

@@ -16,13 +16,13 @@ interface WrappingFixerParams {
      * Receives multiple arguments if there are multiple innerNodes.
      * E.g. ``code => `${code} != null` ``
      */
-    wrap: (...code: string[]) => string;
+    wrap?: (...code: string[]) => string;
 }
 /**
- * Wraps node with some code. Adds parenthesis as necessary.
+ * Wraps node with some code. Adds parentheses as necessary.
  * @returns Fixer which adds the specified code and parens if necessary.
  */
-export declare function getWrappingFixer(params: WrappingFixerParams): TSESLint.ReportFixFunction;
+export declare function getWrappingFixer(params: WrappingFixerParams): (fixer: TSESLint.RuleFixer) => TSESLint.RuleFix;
 /**
  * If the node to be moved and the destination node require parentheses, include parentheses in the node to be moved.
  * @param sourceCode Source code of current file
@@ -36,7 +36,7 @@ export declare function getMovedNodeCode(params: {
     sourceCode: Readonly<TSESLint.SourceCode>;
 }): string;
 /**
- * Check if a node will always have the same precedence if it's parent changes.
+ * Check if a node will always have the same precedence if its parent changes.
  */
 export declare function isStrongPrecedenceNode(innerNode: TSESTree.Node): boolean;
 export {};

node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getWrappingFixer.d.ts","sourceRoot":"","sources":["../../src/util/getWrappingFixer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAQnE,UAAU,mBAAmB;IAC3B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC5C,kCAAkC;IAClC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;IACpB,mBAAmB;IACnB,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC1C;;;;OAIG;IACH,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;CACrC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,GAC1B,QAAQ,CAAC,iBAAiB,CA2C5B;AACD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC/B,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC1B,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;CAC3C,GAAG,MAAM,CAeT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAcxE"}
+{"version":3,"file":"getWrappingFixer.d.ts","sourceRoot":"","sources":["../../src/util/getWrappingFixer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAQnE,UAAU,mBAAmB;IAC3B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC5C,kCAAkC;IAClC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;IACpB,mBAAmB;IACnB,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC1C;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;CACtC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,GAC1B,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,KAAK,QAAQ,CAAC,OAAO,CA+CjD;AACD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC/B,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC1B,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;CAC3C,GAAG,MAAM,CAeT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAcxE"}

node_modules/@typescript-eslint/eslint-plugin/dist/util/getWrappingFixer.js

@@ -5,7 +5,7 @@ exports.getMovedNodeCode = getMovedNodeCode;
 exports.isStrongPrecedenceNode = isStrongPrecedenceNode;
 const utils_1 = require("@typescript-eslint/utils");
 /**
- * Wraps node with some code. Adds parenthesis as necessary.
+ * Wraps node with some code. Adds parentheses as necessary.
  * @returns Fixer which adds the specified code and parens if necessary.
  */
 function getWrappingFixer(params) {
@@ -25,6 +25,9 @@ function getWrappingFixer(params) {
             }
             return code;
         });
+        if (!wrap) {
+            return fixer.replaceText(node, innerCodes.join(''));
+        }
         // do the wrapping
         let code = wrap(...innerCodes);
         // check the outer expression's precedence
@@ -63,7 +66,7 @@ function getMovedNodeCode(params) {
     return `(${code})`;
 }
 /**
- * Check if a node will always have the same precedence if it's parent changes.
+ * Check if a node will always have the same precedence if its parent changes.
  */
 function isStrongPrecedenceNode(innerNode) {
     return (innerNode.type === utils_1.AST_NODE_TYPES.Literal ||

node_modules/@typescript-eslint/eslint-plugin/dist/util/isArrayMethodCallWithPredicate.js

@@ -58,7 +58,7 @@ function isArrayMethodCallWithPredicate(context, services, node) {
     const checker = services.program.getTypeChecker();
     const type = (0, type_utils_1.getConstrainedTypeAtLocation)(services, node.callee.object);
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
-        .flatMap(part => tsutils.intersectionTypeParts(part))
+        .flatMap(part => tsutils.intersectionConstituents(part))
         .some(t => checker.isArrayType(t) || checker.isTupleType(t));
 }

node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.d.ts

@@ -0,0 +1,28 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';
+/**
+ * Parses a syntactically possible `Promise.then()` call. Does not check the
+ * type of the callee.
+ */
+export declare function parseThenCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
+    onFulfilled?: TSESTree.Expression | undefined;
+    onRejected?: TSESTree.Expression | undefined;
+    object: TSESTree.Expression;
+} | undefined;
+/**
+ * Parses a syntactically possible `Promise.catch()` call. Does not check the
+ * type of the callee.
+ */
+export declare function parseCatchCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
+    onRejected?: TSESTree.Expression | undefined;
+    object: TSESTree.Expression;
+} | undefined;
+/**
+ * Parses a syntactically possible `Promise.finally()` call. Does not check the
+ * type of the callee.
+ */
+export declare function parseFinallyCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
+    object: TSESTree.Expression;
+    onFinally?: TSESTree.Expression | undefined;
+} | undefined;
+//# sourceMappingURL=promiseUtils.d.ts.map

node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promiseUtils.d.ts","sourceRoot":"","sources":["../../src/util/promiseUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAMtE;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,WAAW,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9C,UAAU,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC7C,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;CAC7B,GACD,SAAS,CAqCZ;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,UAAU,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC7C,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;CAC7B,GACD,SAAS,CAuBZ;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;IAC5B,SAAS,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;CAC7C,GACD,SAAS,CAsBZ"}

node_modules/@typescript-eslint/eslint-plugin/dist/util/promiseUtils.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseThenCall = parseThenCall;
+exports.parseCatchCall = parseCatchCall;
+exports.parseFinallyCall = parseFinallyCall;
+const utils_1 = require("@typescript-eslint/utils");
+const misc_1 = require("./misc");
+/**
+ * Parses a syntactically possible `Promise.then()` call. Does not check the
+ * type of the callee.
+ */
+function parseThenCall(node, context) {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
+        if (methodName === 'then') {
+            if (node.arguments.length >= 1) {
+                if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    return {
+                        object: node.callee.object,
+                    };
+                }
+                if (node.arguments.length >= 2) {
+                    if (node.arguments[1].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                        return {
+                            object: node.callee.object,
+                            onFulfilled: node.arguments[0],
+                        };
+                    }
+                    return {
+                        object: node.callee.object,
+                        onFulfilled: node.arguments[0],
+                        onRejected: node.arguments[1],
+                    };
+                }
+                return {
+                    object: node.callee.object,
+                    onFulfilled: node.arguments[0],
+                };
+            }
+            return {
+                object: node.callee.object,
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * Parses a syntactically possible `Promise.catch()` call. Does not check the
+ * type of the callee.
+ */
+function parseCatchCall(node, context) {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
+        if (methodName === 'catch') {
+            if (node.arguments.length >= 1) {
+                if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    return {
+                        object: node.callee.object,
+                    };
+                }
+                return {
+                    object: node.callee.object,
+                    onRejected: node.arguments[0],
+                };
+            }
+            return {
+                object: node.callee.object,
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * Parses a syntactically possible `Promise.finally()` call. Does not check the
+ * type of the callee.
+ */
+function parseFinallyCall(node, context) {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
+        if (methodName === 'finally') {
+            if (node.arguments.length >= 1) {
+                if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    return {
+                        object: node.callee.object,
+                    };
+                }
+                return {
+                    object: node.callee.object,
+                    onFinally: node.arguments[0],
+                };
+            }
+            return {
+                object: node.callee.object,
+            };
+        }
+    }
+    return undefined;
+}

node_modules/@typescript-eslint/eslint-plugin/dist/util/truthinessUtils.js

@@ -41,18 +41,18 @@ const getValueOfLiteralType_1 = require("./getValueOfLiteralType");
 const isTruthyLiteral = (type) => tsutils.isTrueLiteralType(type) ||
     (type.isLiteral() && !!(0, getValueOfLiteralType_1.getValueOfLiteralType)(type));
 const isPossiblyFalsy = (type) => tsutils
-    .unionTypeParts(type)
+    .unionConstituents(type)
     // Intersections like `string & {}` can also be possibly falsy,
     // requiring us to look into the intersection.
-    .flatMap(type => tsutils.intersectionTypeParts(type))
+    .flatMap(type => tsutils.intersectionConstituents(type))
     // PossiblyFalsy flag includes literal values, so exclude ones that
     // are definitely truthy
     .filter(t => !isTruthyLiteral(t))
     .some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.PossiblyFalsy));
 exports.isPossiblyFalsy = isPossiblyFalsy;
 const isPossiblyTruthy = (type) => tsutils
-    .unionTypeParts(type)
+    .unionConstituents(type)
-    .map(type => tsutils.intersectionTypeParts(type))
+    .map(type => tsutils.intersectionConstituents(type))
     .some(intersectionParts => 
 // It is possible to define intersections that are always falsy,
 // like `"" & { __brand: string }`.

node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-unnecessary-type-conversion.mdx

@@ -0,0 +1,79 @@
+---
+description: 'Disallow conversion idioms when they do not change the type or value of the expression.'
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-unnecessary-type-conversion** for documentation.
+
+JavaScript provides several commonly used idioms to convert values to a specific type:
+
+- Primitive coercion (e.g. `Boolean(value)`, `String(value)`): using a built-in primitive function
+- String concatenation (e.g. `value + ''`): turning a value into a string
+- Unary coercion (e.g. `+value`, `!!value`): using a built-in operator
+- The `.toString()` method defined on many types
+
+These conversions are unnecessary if the value is already of that type.
+
+## Examples
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts
+String('123');
+'123'.toString();
+'' + '123';
+'123' + '';
+
+Number(123);
++123;
+~~123;
+
+Boolean(true);
+!!true;
+
+BigInt(BigInt(1));
+
+let str = '123';
+str += '';
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts
+function foo(bar: string | number) {
+  String(bar);
+  bar.toString();
+  '' + bar;
+  bar + '';
+
+  Number(bar);
+  +bar;
+  ~~bar;
+
+  Boolean(bar);
+  !!bar;
+
+  BigInt(1);
+
+  bar += '';
+}
+```
+
+</TabItem>
+</Tabs>
+
+## When Not To Use It
+
+If you don't care about having no-op type conversions in your code, then you can turn off this rule.
+If you have types which are not accurate, then this rule might cause you to remove conversions that you actually do need.
+
+## Related To
+
+- [no-unnecessary-type-assertion](./no-unnecessary-type-assertion.mdx)
+- [no-useless-template-literals](./no-useless-template-literals.mdx)

node_modules/@typescript-eslint/eslint-plugin/docs/rules/only-throw-error.mdx

@@ -123,6 +123,11 @@ interface Options {
     | string
   )[];
 
+  /**
+   * Whether to allow rethrowing caught values that are not `Error` objects.
+   */
+  allowRethrowing?: boolean;
+
   /**
    * Whether to always allow throwing values typed as `any`.
    */
@@ -136,6 +141,7 @@ interface Options {
 
 const defaultOptions: Options = {
   allow: [],
+  allowRethrowing: false,
   allowThrowingAny: true,
   allowThrowingUnknown: true,
 };

node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/scope-manager/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/scope-manager",
-  "version": "8.31.1",
+  "version": "8.32.1",
   "description": "TypeScript scope analyser for ESLint",
   "files": [
     "dist",
@@ -38,7 +38,7 @@
   ],
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
-    "clean": "rimraf dist/ _ts4.3/ coverage/",
+    "clean": "rimraf dist/ coverage/",
     "clean-fixtures": "rimraf -g \"./src/**/fixtures/**/snapshots\"",
     "format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
     "generate-lib": "npx nx generate-lib repo",
@@ -47,17 +47,18 @@
     "check-types": "npx nx typecheck"
   },
   "dependencies": {
-    "@typescript-eslint/types": "8.31.1",
+    "@typescript-eslint/types": "8.32.1",
-    "@typescript-eslint/visitor-keys": "8.31.1"
+    "@typescript-eslint/visitor-keys": "8.32.1"
   },
   "devDependencies": {
-    "@typescript-eslint/typescript-estree": "8.31.1",
+    "@typescript-eslint/typescript-estree": "8.32.1",
-    "@vitest/coverage-v8": "^3.1.1",
+    "@vitest/coverage-v8": "^3.1.3",
+    "@vitest/pretty-format": "^3.1.3",
     "glob": "*",
     "prettier": "^3.2.5",
-    "pretty-format": "*",
+    "rimraf": "*",
     "typescript": "*",
-    "vitest": "^3.1.1"
+    "vitest": "^3.1.3"
   },
   "funding": {
     "type": "opencollective",

node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/types",
-  "version": "8.31.1",
+  "version": "8.32.1",
   "description": "Types for the TypeScript-ESTree AST spec",
   "files": [
     "dist",
@@ -67,12 +67,12 @@
     }
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^3.1.1",
+    "@vitest/coverage-v8": "^3.1.3",
     "prettier": "^3.2.5",
     "rimraf": "*",
     "tsx": "*",
     "typescript": "*",
-    "vitest": "^3.1.1"
+    "vitest": "^3.1.3"
   },
   "funding": {
     "type": "opencollective",

node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/typescript-estree/dist/convert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,EAAE,MAAM,aAAa,CAAC;AAmCtE,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,kCAAkC,CAAC,EAAE,OAAO,CAAC;CAC9C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,wBAAwB,GAAG,EAAE,CAAC,sBAAsB,GAC1D,OAAO,CAMT;AAED,MAAM,WAAW,OAAO;IACtB,qBAAqB,EAAE,2BAA2B,CAAC;IACnD,qBAAqB,EAAE,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,qBAAa,SAAS;;IACpB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IAEvD;;;;;OAKG;gBACS,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAsZ1D,OAAO,CAAC,qBAAqB;IAsB7B,OAAO,CAAC,oCAAoC;IAe5C;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAiC9B,OAAO,CAAC,sBAAsB;IA4C9B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;;;;OAKG;IACH,OAAO,CAAC,gDAAgD;IAexD;;;;OAIG;IACH,OAAO,CAAC,kDAAkD;IAmB1D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IA8BjB,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,+BAA+B;IAgDvC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,sBAAsB;IAoC9B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAyhFnB,OAAO,CAAC,UAAU;IAclB,cAAc,IAAI,QAAQ,CAAC,OAAO;IAIlC;;;;OAIG;IACH,OAAO,CAAC,UAAU;IA0FlB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAgFlB,UAAU,IAAI,OAAO;IAOrB;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAYhC"}
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../src/convert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,EAAE,MAAM,aAAa,CAAC;AAmCtE,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,kCAAkC,CAAC,EAAE,OAAO,CAAC;CAC9C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,wBAAwB,GAAG,EAAE,CAAC,sBAAsB,GAC1D,OAAO,CAMT;AAED,MAAM,WAAW,OAAO;IACtB,qBAAqB,EAAE,2BAA2B,CAAC;IACnD,qBAAqB,EAAE,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,qBAAa,SAAS;;IACpB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAiB;IAEvD;;;;;OAKG;gBACS,GAAG,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAsZ1D,OAAO,CAAC,qBAAqB;IAsB7B,OAAO,CAAC,oCAAoC;IAe5C;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAiC9B,OAAO,CAAC,sBAAsB;IA4C9B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;;;;OAKG;IACH,OAAO,CAAC,gDAAgD;IAexD;;;;OAIG;IACH,OAAO,CAAC,kDAAkD;IAmB1D;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IA8BjB,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,+BAA+B;IAgDvC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,sBAAsB;IAoC9B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAiiFnB,OAAO,CAAC,UAAU;IAclB,cAAc,IAAI,QAAQ,CAAC,OAAO;IAIlC;;;;OAIG;IACH,OAAO,CAAC,UAAU;IA0FlB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAgFlB,UAAU,IAAI,OAAO;IAOrB;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAYhC"}

node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/typescript-estree/dist/convert.js

@@ -2081,12 +2081,14 @@ class Converter {
                     constraint: this.convertChild(node.typeParameter.constraint),
                     key: this.convertChild(node.typeParameter.name),
                     nameType: this.convertChild(node.nameType) ?? null,
-                    optional: node.questionToken &&
+                    optional: node.questionToken
-                        (node.questionToken.kind === SyntaxKind.QuestionToken ||
+                        ? node.questionToken.kind === SyntaxKind.QuestionToken ||
-                            (0, node_utils_1.getTextForTokenKind)(node.questionToken.kind)),
+                            (0, node_utils_1.getTextForTokenKind)(node.questionToken.kind)
-                    readonly: node.readonlyToken &&
+                        : false,
-                        (node.readonlyToken.kind === SyntaxKind.ReadonlyKeyword ||
+                    readonly: node.readonlyToken
-                            (0, node_utils_1.getTextForTokenKind)(node.readonlyToken.kind)),
+                        ? node.readonlyToken.kind === SyntaxKind.ReadonlyKeyword ||
+                            (0, node_utils_1.getTextForTokenKind)(node.readonlyToken.kind)
+                        : undefined,
                     typeAnnotation: node.type && this.convertChild(node.type),
                 }, 'typeParameter', "'constraint' and 'key'", this.convertChild(node.typeParameter)));
             }
@@ -2250,21 +2252,24 @@ class Converter {
                     const commaToken = (0, node_utils_1.findNextToken)(node.argument, node, this.ast);
                     const openBraceToken = (0, node_utils_1.findNextToken)(commaToken, node, this.ast);
                     const closeBraceToken = (0, node_utils_1.findNextToken)(node.attributes, node, this.ast);
-                    const withToken = (0, node_utils_1.findNextToken)(openBraceToken, node, this.ast);
+                    const withOrAssertToken = (0, node_utils_1.findNextToken)(openBraceToken, node, this.ast);
-                    const withTokenRange = (0, node_utils_1.getRange)(withToken, this.ast);
+                    const withOrAssertTokenRange = (0, node_utils_1.getRange)(withOrAssertToken, this.ast);
+                    const withOrAssertName = withOrAssertToken.kind === ts.SyntaxKind.AssertKeyword
+                        ? 'assert'
+                        : 'with';
                     options = this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.ObjectExpression,
                         range: [openBraceToken.getStart(this.ast), closeBraceToken.end],
                         properties: [
                             this.createNode(node, {
                                 type: ts_estree_1.AST_NODE_TYPES.Property,
-                                range: [withTokenRange[0], node.attributes.end],
+                                range: [withOrAssertTokenRange[0], node.attributes.end],
                                 computed: false,
                                 key: this.createNode(node, {
                                     type: ts_estree_1.AST_NODE_TYPES.Identifier,
-                                    range: withTokenRange,
+                                    range: withOrAssertTokenRange,
                                     decorators: [],
-                                    name: 'with',
+                                    name: withOrAssertName,
                                     optional: false,
                                     typeAnnotation: undefined,
                                 }),

node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/typescript-estree/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "8.31.1",
+  "version": "8.32.1",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "files": [
     "dist",
@@ -45,30 +45,30 @@
   ],
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
-    "clean": "tsc -b tsconfig.build.json --clean",
+    "clean": "rimraf dist/ coverage/",
-    "postclean": "rimraf dist/ coverage/",
     "format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
     "lint": "npx nx lint",
     "test": "vitest --run --config=$INIT_CWD/vitest.config.mts",
     "check-types": "npx nx typecheck"
   },
   "dependencies": {
-    "@typescript-eslint/types": "8.31.1",
+    "@typescript-eslint/types": "8.32.1",
-    "@typescript-eslint/visitor-keys": "8.31.1",
+    "@typescript-eslint/visitor-keys": "8.32.1",
     "debug": "^4.3.4",
     "fast-glob": "^3.3.2",
     "is-glob": "^4.0.3",
     "minimatch": "^9.0.4",
     "semver": "^7.6.0",
-    "ts-api-utils": "^2.0.1"
+    "ts-api-utils": "^2.1.0"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^3.1.1",
+    "@types/is-glob": "^4.0.4",
+    "@vitest/coverage-v8": "^3.1.3",
     "glob": "*",
     "prettier": "^3.2.5",
     "rimraf": "*",
     "typescript": "*",
-    "vitest": "^3.1.1"
+    "vitest": "^3.1.3"
   },
   "peerDependencies": {
     "typescript": ">=4.8.4 <5.9.0"

node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/utils",
-  "version": "8.31.1",
+  "version": "8.32.1",
   "description": "Utilities for working with TypeScript + ESLint together",
   "files": [
     "dist",
@@ -62,21 +62,21 @@
     "check-types": "npx nx typecheck"
   },
   "dependencies": {
-    "@eslint-community/eslint-utils": "^4.4.0",
+    "@eslint-community/eslint-utils": "^4.7.0",
-    "@typescript-eslint/scope-manager": "8.31.1",
+    "@typescript-eslint/scope-manager": "8.32.1",
-    "@typescript-eslint/types": "8.31.1",
+    "@typescript-eslint/types": "8.32.1",
-    "@typescript-eslint/typescript-estree": "8.31.1"
+    "@typescript-eslint/typescript-estree": "8.32.1"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <5.9.0"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^3.1.1",
+    "@vitest/coverage-v8": "^3.1.3",
     "prettier": "^3.2.5",
     "rimraf": "*",
     "typescript": "*",
-    "vitest": "^3.1.1"
+    "vitest": "^3.1.3"
   },
   "funding": {
     "type": "opencollective",

node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/visitor-keys/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/visitor-keys",
-  "version": "8.31.1",
+  "version": "8.32.1",
   "description": "Visitor keys used to help traverse the TypeScript-ESTree AST",
   "files": [
     "dist",
@@ -46,15 +46,15 @@
     "check-types": "npx nx typecheck"
   },
   "dependencies": {
-    "@typescript-eslint/types": "8.31.1",
+    "@typescript-eslint/types": "8.32.1",
     "eslint-visitor-keys": "^4.2.0"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^3.1.1",
+    "@vitest/coverage-v8": "^3.1.3",
     "prettier": "^3.2.5",
     "rimraf": "*",
     "typescript": "*",
-    "vitest": "^3.1.1"
+    "vitest": "^3.1.3"
   },
   "funding": {
     "type": "opencollective",

node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore/LICENSE-MIT

@@ -0,0 +1,21 @@
+Copyright (c) 2013 Kael Zhang <i@kael.me>, contributors
+http://kael.me/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore/README.md

@@ -0,0 +1,452 @@
+| Linux / MacOS / Windows | Coverage | Downloads |
+| ----------------------- | -------- | --------- |
+| [![build][bb]][bl]      | [![coverage][cb]][cl] | [![downloads][db]][dl] |
+
+[bb]: https://github.com/kaelzhang/node-ignore/actions/workflows/nodejs.yml/badge.svg
+[bl]: https://github.com/kaelzhang/node-ignore/actions/workflows/nodejs.yml
+
+[cb]: https://codecov.io/gh/kaelzhang/node-ignore/branch/master/graph/badge.svg
+[cl]: https://codecov.io/gh/kaelzhang/node-ignore
+
+[db]: http://img.shields.io/npm/dm/ignore.svg
+[dl]: https://www.npmjs.org/package/ignore
+
+# ignore
+
+`ignore` is a manager, filter and parser which implemented in pure JavaScript according to the [.gitignore spec 2.22.1](http://git-scm.com/docs/gitignore).
+
+`ignore` is used by eslint, gitbook and [many others](https://www.npmjs.com/browse/depended/ignore).
+
+Pay **ATTENTION** that [`minimatch`](https://www.npmjs.org/package/minimatch) (which used by `fstream-ignore`) does not follow the gitignore spec.
+
+To filter filenames according to a .gitignore file, I recommend this npm package, `ignore`.
+
+To parse an `.npmignore` file, you should use `minimatch`, because an `.npmignore` file is parsed by npm using `minimatch` and it does not work in the .gitignore way.
+
+### Tested on
+
+`ignore` is fully tested, and has more than **five hundreds** of unit tests.
+
+- Linux + Node: `0.8` - `7.x`
+- Windows + Node: `0.10` - `7.x`, node < `0.10` is not tested due to the lack of support of appveyor.
+
+Actually, `ignore` does not rely on any versions of node specially.
+
+Since `4.0.0`, ignore will no longer support `node < 6` by default, to use in node < 6, `require('ignore/legacy')`. For details, see [CHANGELOG](https://github.com/kaelzhang/node-ignore/blob/master/CHANGELOG.md).
+
+## Table Of Main Contents
+
+- [Usage](#usage)
+- [`Pathname` Conventions](#pathname-conventions)
+- See Also:
+  - [`glob-gitignore`](https://www.npmjs.com/package/glob-gitignore) matches files using patterns and filters them according to gitignore rules.
+- [Upgrade Guide](#upgrade-guide)
+
+## Install
+
+```sh
+npm i ignore
+```
+
+## Usage
+
+```js
+import ignore from 'ignore'
+const ig = ignore().add(['.abc/*', '!.abc/d/'])
+```
+
+### Filter the given paths
+
+```js
+const paths = [
+  '.abc/a.js',    // filtered out
+  '.abc/d/e.js'   // included
+]
+
+ig.filter(paths)        // ['.abc/d/e.js']
+ig.ignores('.abc/a.js') // true
+```
+
+### As the filter function
+
+```js
+paths.filter(ig.createFilter()); // ['.abc/d/e.js']
+```
+
+### Win32 paths will be handled
+
+```js
+ig.filter(['.abc\\a.js', '.abc\\d\\e.js'])
+// if the code above runs on windows, the result will be
+// ['.abc\\d\\e.js']
+```
+
+## Why another ignore?
+
+- `ignore` is a standalone module, and is much simpler so that it could easy work with other programs, unlike [isaacs](https://npmjs.org/~isaacs)'s [fstream-ignore](https://npmjs.org/package/fstream-ignore) which must work with the modules of the fstream family.
+
+- `ignore` only contains utility methods to filter paths according to the specified ignore rules, so
+  - `ignore` never try to find out ignore rules by traversing directories or fetching from git configurations.
+  - `ignore` don't cares about sub-modules of git projects.
+
+- Exactly according to [gitignore man page](http://git-scm.com/docs/gitignore), fixes some known matching issues of fstream-ignore, such as:
+  - '`/*.js`' should only match '`a.js`', but not '`abc/a.js`'.
+  - '`**/foo`' should match '`foo`' anywhere.
+  - Prevent re-including a file if a parent directory of that file is excluded.
+  - Handle trailing whitespaces:
+    - `'a '`(one space) should not match `'a  '`(two spaces).
+    - `'a \ '` matches `'a  '`
+  - All test cases are verified with the result of `git check-ignore`.
+
+# Methods
+
+## .add(pattern: string | Ignore): this
+## .add(patterns: Array<string | Ignore>): this
+## .add({pattern: string, mark?: string}): this  since 7.0.0
+
+- **pattern** `string | Ignore` An ignore pattern string, or the `Ignore` instance
+- **patterns** `Array<string | Ignore>` Array of ignore patterns.
+- **mark?** `string` Pattern mark, which is used to associate the pattern with a certain marker, such as the line no of the `.gitignore` file. Actually it could be an arbitrary string and is optional.
+
+Adds a rule or several rules to the current manager.
+
+Returns `this`
+
+Notice that a line starting with `'#'`(hash) is treated as a comment. Put a backslash (`'\'`) in front of the first hash for patterns that begin with a hash, if you want to ignore a file with a hash at the beginning of the filename.
+
+```js
+ignore().add('#abc').ignores('#abc')    // false
+ignore().add('\\#abc').ignores('#abc')   // true
+```
+
+`pattern` could either be a line of ignore pattern or a string of multiple ignore patterns, which means we could just `ignore().add()` the content of a ignore file:
+
+```js
+ignore()
+.add(fs.readFileSync(filenameOfGitignore).toString())
+.filter(filenames)
+```
+
+`pattern` could also be an `ignore` instance, so that we could easily inherit the rules of another `Ignore` instance.
+
+## .ignores(pathname: [Pathname](#pathname-conventions)): boolean
+
+> new in 3.2.0
+
+Returns `Boolean` whether `pathname` should be ignored.
+
+```js
+ig.ignores('.abc/a.js')    // true
+```
+
+Please **PAY ATTENTION** that `.ignores()` is **NOT** equivalent to `git check-ignore` although in most cases they return equivalent results.
+
+However, for the purposes of imitating the behavior of `git check-ignore`, please use `.checkIgnore()` instead.
+
+### `Pathname` Conventions:
+
+#### 1. `Pathname` should be a `path.relative()`d pathname
+
+`Pathname` should be a string that have been `path.join()`ed, or the return value of `path.relative()` to the current directory,
+
+```js
+// WRONG, an error will be thrown
+ig.ignores('./abc')
+
+// WRONG, for it will never happen, and an error will be thrown
+// If the gitignore rule locates at the root directory,
+// `'/abc'` should be changed to `'abc'`.
+// ```
+// path.relative('/', '/abc')  -> 'abc'
+// ```
+ig.ignores('/abc')
+
+// WRONG, that it is an absolute path on Windows, an error will be thrown
+ig.ignores('C:\\abc')
+
+// Right
+ig.ignores('abc')
+
+// Right
+ig.ignores(path.join('./abc'))  // path.join('./abc') -> 'abc'
+```
+
+In other words, each `Pathname` here should be a relative path to the directory of the gitignore rules.
+
+Suppose the dir structure is:
+
+```
+/path/to/your/repo
+    |-- a
+    |   |-- a.js
+    |
+    |-- .b
+    |
+    |-- .c
+         |-- .DS_store
+```
+
+Then the `paths` might be like this:
+
+```js
+[
+  'a/a.js'
+  '.b',
+  '.c/.DS_store'
+]
+```
+
+#### 2. filenames and dirnames
+
+`node-ignore` does NO `fs.stat` during path matching, so `node-ignore` treats
+- `foo` as a file
+- **`foo/` as a directory**
+
+For the example below:
+
+```js
+// First, we add a ignore pattern to ignore a directory
+ig.add('config/')
+
+// `ig` does NOT know if 'config', in the real world,
+//   is a normal file, directory or something.
+
+ig.ignores('config')
+// `ig` treats `config` as a file, so it returns `false`
+
+ig.ignores('config/')
+// returns `true`
+```
+
+Specially for people who develop some library based on `node-ignore`, it is important to understand that.
+
+Usually, you could use [`glob`](http://npmjs.org/package/glob) with `option.mark = true` to fetch the structure of the current directory:
+
+```js
+import glob from 'glob'
+
+glob('**', {
+  // Adds a / character to directory matches.
+  mark: true
+}, (err, files) => {
+  if (err) {
+    return console.error(err)
+  }
+
+  let filtered = ignore().add(patterns).filter(files)
+  console.log(filtered)
+})
+```
+
+
+## .filter(paths: Array&lt;Pathname&gt;): Array&lt;Pathname&gt;
+
+```ts
+type Pathname = string
+```
+
+Filters the given array of pathnames, and returns the filtered array.
+
+- **paths** `Array.<Pathname>` The array of `pathname`s to be filtered.
+
+## .createFilter()
+
+Creates a filter function which could filter an array of paths with `Array.prototype.filter`.
+
+Returns `function(path)` the filter function.
+
+## .test(pathname: Pathname): TestResult
+
+> New in 5.0.0
+
+Returns `TestResult`
+
+```ts
+// Since 5.0.0
+interface TestResult {
+  ignored: boolean
+  // true if the `pathname` is finally unignored by some negative pattern
+  unignored: boolean
+  // The `IgnoreRule` which ignores the pathname
+  rule?: IgnoreRule
+}
+
+// Since 7.0.0
+interface IgnoreRule {
+  // The original pattern
+  pattern: string
+  // Whether the pattern is a negative pattern
+  negative: boolean
+  // Which is used for other packages to build things upon `node-ignore`
+  mark?: string
+}
+```
+
+- `{ignored: true, unignored: false}`: the `pathname` is ignored
+- `{ignored: false, unignored: true}`: the `pathname` is unignored
+- `{ignored: false, unignored: false}`: the `pathname` is never matched by any ignore rules.
+
+## .checkIgnore(target: string): TestResult
+
+> new in 7.0.0
+
+Debugs gitignore / exclude files, which is equivalent to `git check-ignore -v`. Usually this method is used for other packages to implement the function of `git check-ignore -v` upon `node-ignore`
+
+- **target** `string` the target to test.
+
+Returns `TestResult`
+
+```js
+ig.add({
+  pattern: 'foo/*',
+  mark: '60'
+})
+
+const {
+  ignored,
+  rule
+} = checkIgnore('foo/')
+
+if (ignored) {
+  console.log(`.gitignore:${result}:${rule.mark}:${rule.pattern} foo/`)
+}
+
+// .gitignore:60:foo/* foo/
+```
+
+Please pay attention that this method does not have a strong built-in cache mechanism.
+
+The purpose of introducing this method is to make it possible to implement the `git check-ignore` command in JavaScript based on `node-ignore`.
+
+So do not use this method in those situations where performance is extremely important.
+
+## static `isPathValid(pathname): boolean` since 5.0.0
+
+Check whether the `pathname` is an valid `path.relative()`d path according to the [convention](#1-pathname-should-be-a-pathrelatived-pathname).
+
+This method is **NOT** used to check if an ignore pattern is valid.
+
+```js
+import {isPathValid} from 'ignore'
+
+isPathValid('./foo')  // false
+```
+
+## <strike>.addIgnoreFile(path)</strike>
+
+REMOVED in `3.x` for now.
+
+To upgrade `ignore@2.x` up to `3.x`, use
+
+```js
+import fs from 'fs'
+
+if (fs.existsSync(filename)) {
+  ignore().add(fs.readFileSync(filename).toString())
+}
+```
+
+instead.
+
+## ignore(options)
+
+### `options.ignorecase` since 4.0.0
+
+Similar as the `core.ignorecase` option of [git-config](https://git-scm.com/docs/git-config), `node-ignore` will be case insensitive if `options.ignorecase` is set to `true` (the default value), otherwise case sensitive.
+
+```js
+const ig = ignore({
+  ignorecase: false
+})
+
+ig.add('*.png')
+
+ig.ignores('*.PNG')  // false
+```
+
+### `options.ignoreCase?: boolean` since 5.2.0
+
+Which is alternative to `options.ignoreCase`
+
+### `options.allowRelativePaths?: boolean` since 5.2.0
+
+This option brings backward compatibility with projects which based on `ignore@4.x`. If `options.allowRelativePaths` is `true`, `ignore` will not check whether the given path to be tested is [`path.relative()`d](#pathname-conventions).
+
+However, passing a relative path, such as `'./foo'` or `'../foo'`, to test if it is ignored or not is not a good practise, which might lead to unexpected behavior
+
+```js
+ignore({
+  allowRelativePaths: true
+}).ignores('../foo/bar.js') // And it will not throw
+```
+
+****
+
+# Upgrade Guide
+
+## Upgrade 4.x -> 5.x
+
+Since `5.0.0`, if an invalid `Pathname` passed into `ig.ignores()`, an error will be thrown, unless `options.allowRelative = true` is passed to the `Ignore` factory.
+
+While `ignore < 5.0.0` did not make sure what the return value was, as well as
+
+```ts
+.ignores(pathname: Pathname): boolean
+
+.filter(pathnames: Array<Pathname>): Array<Pathname>
+
+.createFilter(): (pathname: Pathname) => boolean
+
+.test(pathname: Pathname): {ignored: boolean, unignored: boolean}
+```
+
+See the convention [here](#1-pathname-should-be-a-pathrelatived-pathname) for details.
+
+If there are invalid pathnames, the conversion and filtration should be done by users.
+
+```js
+import {isPathValid} from 'ignore' // introduced in 5.0.0
+
+const paths = [
+  // invalid
+  //////////////////
+  '',
+  false,
+  '../foo',
+  '.',
+  //////////////////
+
+  // valid
+  'foo'
+]
+.filter(isPathValid)
+
+ig.filter(paths)
+```
+
+## Upgrade 3.x -> 4.x
+
+Since `4.0.0`, `ignore` will no longer support node < 6, to use `ignore` in node < 6:
+
+```js
+var ignore = require('ignore/legacy')
+```
+
+## Upgrade 2.x -> 3.x
+
+- All `options` of 2.x are unnecessary and removed, so just remove them.
+- `ignore()` instance is no longer an [`EventEmitter`](nodejs.org/api/events.html), and all events are unnecessary and removed.
+- `.addIgnoreFile()` is removed, see the [.addIgnoreFile](#addignorefilepath) section for details.
+
+****
+
+# Collaborators
+
+- [@whitecolor](https://github.com/whitecolor) *Alex*
+- [@SamyPesse](https://github.com/SamyPesse) *Samy Pessé*
+- [@azproduction](https://github.com/azproduction) *Mikhail Davydov*
+- [@TrySound](https://github.com/TrySound) *Bogdan Chadkin*
+- [@JanMattner](https://github.com/JanMattner) *Jan Mattner*
+- [@ntwb](https://github.com/ntwb) *Stephen Edgar*
+- [@kasperisager](https://github.com/kasperisager) *Kasper Isager*
+- [@sandersn](https://github.com/sandersn) *Nathan Shively-Sanders*