eslint-plugin-etc-misc 1.1.1 → 1.1.3

package/dist/plugin.cjs

@@ -42,10 +42,10 @@ var pluginMeta = {
 };
 
 // dist/configs/all-strict.js
-var import_ts_extras66 = require("ts-extras");
+var import_ts_extras69 = require("ts-extras");
 
 // dist/rules.js
-var import_ts_extras65 = require("ts-extras");
+var import_ts_extras68 = require("ts-extras");
 
 // dist/_internal/rule-catalog.js
 var toCatalogNumericPart = (catalogIndex) => `${catalogIndex}`.padStart(3, "0");
@@ -155,14 +155,14 @@ var createDeprecatedRuleInfo = ({ message, replacedBy = [], ruleId }) => ({
   ...replacedBy.length === 0 ? {} : { replacedBy: [...replacedBy] },
   url: `${docsBaseUrl}/${ruleId.replaceAll("/", "-")}`
 });
-var withDeprecatedRuleLifecycle = (rule130, options) => ({
-  ...rule130,
+var withDeprecatedRuleLifecycle = (rule133, options) => ({
+  ...rule133,
   meta: {
-    ...rule130.meta,
+    ...rule133.meta,
     deprecated: createDeprecatedRuleInfo(options),
-    ...rule130.meta.docs === void 0 ? {} : {
+    ...rule133.meta.docs === void 0 ? {} : {
       docs: {
-        ...rule130.meta.docs,
+        ...rule133.meta.docs,
         deprecated: true,
         frozen: true
       }
@@ -1941,10 +1941,96 @@ var rule25 = ruleCreator({
 });
 var no_foreach_default = rule25;
 
+// dist/rules/no-function-declare-after-return.js
+var import_ts_extras23 = require("ts-extras");
+var isStatementList = (node) => node.type === "BlockStatement" || node.type === "Program";
+var getLineStartIndex = (sourceText, index) => sourceText.lastIndexOf("\n", index - 1) + 1;
+var getSafeFixRangeStart = (sourceCode, node) => {
+  const declarationStart = (0, import_ts_extras23.arrayFirst)(node.range) ?? 0;
+  const tokenBeforeDeclaration = sourceCode.getTokenBefore(node);
+  const tokenBeforeEnd = tokenBeforeDeclaration === null ? 0 : (0, import_ts_extras23.arrayLast)(tokenBeforeDeclaration.range) ?? 0;
+  const commentsBeforeDeclaration = sourceCode.getCommentsBefore(node).filter((comment) => ((0, import_ts_extras23.arrayFirst)(comment.range) ?? 0) >= tokenBeforeEnd && ((0, import_ts_extras23.arrayLast)(comment.range) ?? 0) <= declarationStart);
+  const firstLeadingComment = (0, import_ts_extras23.arrayFirst)(commentsBeforeDeclaration);
+  const firstMovableNodeStart = firstLeadingComment === void 0 ? declarationStart : (0, import_ts_extras23.arrayFirst)(firstLeadingComment.range) ?? declarationStart;
+  return getLineStartIndex(sourceCode.text, firstMovableNodeStart);
+};
+var getSafeFixRangeEnd = (sourceCode, node) => {
+  const declarationEnd = (0, import_ts_extras23.arrayLast)(node.range) ?? 0;
+  const tokenAfterDeclaration = sourceCode.getTokenAfter(node);
+  if (tokenAfterDeclaration === null) {
+    return declarationEnd;
+  }
+  return getLineStartIndex(sourceCode.text, (0, import_ts_extras23.arrayFirst)(tokenAfterDeclaration.range) ?? declarationEnd);
+};
+var rule26 = ruleCreator({
+  create: (context) => ({
+    ReturnStatement(node) {
+      const parent = node.parent;
+      if (!isStatementList(parent)) {
+        return;
+      }
+      const siblings = parent.body;
+      const returnIndex = siblings.indexOf(node);
+      for (let i = returnIndex + 1; i < siblings.length; i++) {
+        const sibling = siblings[i];
+        if (sibling?.type !== "FunctionDeclaration") {
+          continue;
+        }
+        const functionDeclaration = sibling;
+        const returnStatement = node;
+        context.report({
+          data: {
+            name: functionDeclaration.id?.name ?? "(anonymous)"
+          },
+          fix(fixer) {
+            const sourceCode = context.sourceCode;
+            const declarationEnd = (0, import_ts_extras23.arrayLast)(functionDeclaration.range) ?? 0;
+            const fixRangeStart = getSafeFixRangeStart(sourceCode, functionDeclaration);
+            const fixRangeEnd = getSafeFixRangeEnd(sourceCode, functionDeclaration);
+            const functionAndLeadingCommentsText = sourceCode.text.slice(fixRangeStart, declarationEnd);
+            if (functionAndLeadingCommentsText.trim().length === 0) {
+              return null;
+            }
+            const returnToken = sourceCode.getFirstToken(returnStatement);
+            const indentationEnd = (0, import_ts_extras23.arrayFirst)(returnToken?.range ?? [0]) ?? 0;
+            const returnLineStart = getLineStartIndex(sourceCode.text, indentationEnd);
+            return [
+              fixer.insertTextBeforeRange([returnLineStart, returnLineStart], `${functionAndLeadingCommentsText}
+`),
+              fixer.removeRange([fixRangeStart, fixRangeEnd])
+            ];
+          },
+          messageId: "forbidden",
+          node: functionDeclaration
+        });
+      }
+    }
+  }),
+  meta: {
+    deprecated: false,
+    docs: {
+      deprecated: false,
+      description: "disallow function declarations after a return statement.",
+      frozen: false,
+      recommended: true,
+      url: "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-function-declare-after-return"
+    },
+    fixable: "code",
+    hasSuggestions: false,
+    messages: {
+      forbidden: "Function declaration '{{name}}' should be moved before the return statement for readability."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "no-function-declare-after-return"
+});
+var no_function_declare_after_return_default = rule26;
+
 // dist/rules/no-implicit-any-catch.js
 var import_type_utils4 = require("@typescript-eslint/type-utils");
 var import_utils5 = require("@typescript-eslint/utils");
-var import_ts_extras23 = require("ts-extras");
+var import_ts_extras24 = require("ts-extras");
 var defaultOptions5 = [{}];
 var isPromiseRejectionCall = (callExpression, parserServices, program) => {
   const { callee } = callExpression;
@@ -1960,7 +2046,7 @@ var isParenthesized = (sourceCode, node) => {
   if (tokenBefore === null || tokenAfter === null) {
     return false;
   }
-  return tokenBefore.value === "(" && tokenBefore.range[1] <= (0, import_ts_extras23.arrayFirst)(node.range) && tokenAfter.value === ")" && (0, import_ts_extras23.arrayFirst)(tokenAfter.range) >= node.range[1];
+  return tokenBefore.value === "(" && tokenBefore.range[1] <= (0, import_ts_extras24.arrayFirst)(node.range) && tokenAfter.value === ")" && (0, import_ts_extras24.arrayFirst)(tokenAfter.range) >= node.range[1];
 };
 var replaceWithUnknownFix = (fixer, typeAnnotation) => fixer.replaceText(typeAnnotation, ": unknown");
 var annotateImplicitParamFixes = (fixer, sourceCode, parameter) => {
@@ -1972,7 +2058,7 @@ var annotateImplicitParamFixes = (fixer, sourceCode, parameter) => {
     fixer.insertTextAfter(parameter, ": unknown)")
   ];
 };
-var rule26 = ruleCreator({
+var rule27 = ruleCreator({
   create: (context) => {
     const parserServices = import_utils5.ESLintUtils.getParserServices(context);
     const sourceCode = context.sourceCode;
@@ -2088,18 +2174,18 @@ var rule26 = ruleCreator({
   },
   name: "no-implicit-any-catch"
 });
-var no_implicit_any_catch_default = rule26;
+var no_implicit_any_catch_default = rule27;
 
 // dist/rules/no-index-import.js
-var rule27 = createImportPatternRule({
+var rule28 = createImportPatternRule({
   defaultDisallowPatterns: ["."],
   description: "disallow imports from the current directory root (.).",
   name: "no-index-import"
 });
-var no_index_import_default = rule27;
+var no_index_import_default = rule28;
 
 // dist/rules/no-internal-modules.js
-var rule28 = createImportPatternRule({
+var rule29 = createImportPatternRule({
   defaultDisallowPatterns: [
     "./*/**",
     "[^@]*/**",
@@ -2108,13 +2194,13 @@ var rule28 = createImportPatternRule({
   description: "disallow importing internal modules.",
   name: "no-internal-modules"
 });
-var no_internal_modules_default = rule28;
+var no_internal_modules_default = rule29;
 
 // dist/rules/no-internal.js
 var import_utils6 = require("@typescript-eslint/utils");
-var import_ts_extras24 = require("ts-extras");
+var import_ts_extras25 = require("ts-extras");
 var defaultOptions6 = [{}];
-var rule29 = ruleCreator({
+var rule30 = ruleCreator({
   create: (context) => {
     const [{ ignored = {} } = {}] = context.options;
     const parserServices = import_utils6.ESLintUtils.getParserServices(context);
@@ -2130,7 +2216,7 @@ var rule29 = ruleCreator({
           return;
         }
         const symbol = getIdentifierSymbol(parserServices, node);
-        if (!(0, import_ts_extras24.isDefined)(symbol)) {
+        if (!(0, import_ts_extras25.isDefined)(symbol)) {
           return;
         }
         const symbolName = symbol.getName();
@@ -2142,11 +2228,11 @@ var rule29 = ruleCreator({
           return;
         }
         const internalComments = getJsDocTagComments(symbol, typeChecker, "internal");
-        if ((0, import_ts_extras24.isEmpty)(internalComments)) {
+        if ((0, import_ts_extras25.isEmpty)(internalComments)) {
           return;
         }
         for (const comment of internalComments) {
-          if (!(0, import_ts_extras24.isDefined)(comment)) {
+          if (!(0, import_ts_extras25.isDefined)(comment)) {
             context.report({
               data: { name: symbolName },
               messageId: "forbidden",
@@ -2217,16 +2303,16 @@ var rule29 = ruleCreator({
   },
   name: "no-internal"
 });
-var no_internal_default = rule29;
+var no_internal_default = rule30;
 
 // dist/rules/no-language-mixing.js
-var import_ts_extras25 = require("ts-extras");
+var import_ts_extras26 = require("ts-extras");
 var languageMixPattern = String.raw`/\w[\d_]*[^\u0000-\xff]|[^\u0000-\xff][\d_]*\w/u`;
-var disallowedSelector5 = (0, import_ts_extras25.arrayJoin)([
+var disallowedSelector5 = (0, import_ts_extras26.arrayJoin)([
   `Literal[value=${languageMixPattern}]`,
   `TemplateElement[value.raw=${languageMixPattern}]`
 ], ", ");
-var rule30 = ruleCreator({
+var rule31 = ruleCreator({
   create: (context) => ({
     [disallowedSelector5]: (node) => {
       context.report({
@@ -2253,11 +2339,11 @@ var rule30 = ruleCreator({
   },
   name: "no-language-mixing"
 });
-var no_language_mixing_default = rule30;
+var no_language_mixing_default = rule31;
 
 // dist/rules/no-misused-generics.js
 var import_utils7 = require("@typescript-eslint/utils");
-var import_ts_extras26 = require("ts-extras");
+var import_ts_extras27 = require("ts-extras");
 var tsutils = __toESM(require("tsutils"), 1);
 var getVariableUses = (usageMap, identifier) => usageMap.get(identifier)?.uses ?? [];
 var toReportLocation = (sourceCode, sourceFile, node) => {
@@ -2276,14 +2362,14 @@ var toReportLocation = (sourceCode, sourceFile, node) => {
 };
 var isTypeUseInsideConstraint = (useLocation, typeParameters) => typeParameters.some((typeParameter) => {
   const { constraint } = typeParameter;
-  if (!(0, import_ts_extras26.isDefined)(constraint)) {
+  if (!(0, import_ts_extras27.isDefined)(constraint)) {
     return false;
   }
   return useLocation.pos >= constraint.pos && useLocation.pos < constraint.end;
 });
 var isConstrainedByAnotherTypeParameter = (currentTypeParameter, allTypeParameters, usageMap) => {
   const { constraint } = currentTypeParameter;
-  if (!(0, import_ts_extras26.isDefined)(constraint)) {
+  if (!(0, import_ts_extras27.isDefined)(constraint)) {
     return false;
   }
   return allTypeParameters.some((otherTypeParameter) => {
@@ -2297,7 +2383,7 @@ var isConstrainedByAnotherTypeParameter = (currentTypeParameter, allTypeParamete
 var isUseWithinParameterRange = (usePosition, signature) => usePosition > signature.parameters.pos && usePosition < signature.parameters.end;
 var getTypeParameterReplacement = (sourceFile, typeParameter) => {
   const { constraint } = typeParameter;
-  if (!(0, import_ts_extras26.isDefined)(constraint)) {
+  if (!(0, import_ts_extras27.isDefined)(constraint)) {
     return "unknown";
   }
   return constraint.getText(sourceFile);
@@ -2326,7 +2412,7 @@ var analyzeTypeParameterUses = (uses, signature, typeParameters) => {
     usedInReturnOrExtends
   };
 };
-var rule31 = ruleCreator({
+var rule32 = ruleCreator({
   create: (context) => {
     const parserServices = import_utils7.ESLintUtils.getParserServices(context);
     let usageMap = null;
@@ -2363,7 +2449,7 @@ var rule31 = ruleCreator({
     };
     const checkSignature = (node) => {
       const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-      if (!tsutils.isSignatureDeclaration(tsNode) || !(0, import_ts_extras26.isDefined)(tsNode.typeParameters)) {
+      if (!tsutils.isSignatureDeclaration(tsNode) || !(0, import_ts_extras27.isDefined)(tsNode.typeParameters)) {
         return;
       }
       checkTypeParameters(tsNode.typeParameters, tsNode);
@@ -2406,12 +2492,12 @@ var rule31 = ruleCreator({
   },
   name: "no-misused-generics"
 });
-var no_misused_generics_default = rule31;
+var no_misused_generics_default = rule32;
 
 // dist/rules/no-mixed-enums.js
 var import_eslint_plugin2 = __toESM(require("@typescript-eslint/eslint-plugin"), 1);
-var rule32 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin2.default, "no-mixed-enums", "@typescript-eslint/eslint-plugin"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-mixed-enums");
-var deprecatedRule6 = withDeprecatedRuleLifecycle(rule32, {
+var rule33 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin2.default, "no-mixed-enums", "@typescript-eslint/eslint-plugin"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-mixed-enums");
+var deprecatedRule6 = withDeprecatedRuleLifecycle(rule33, {
   message: "Deprecated in favor of @typescript-eslint/no-mixed-enums.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -2430,7 +2516,7 @@ var deprecatedRule6 = withDeprecatedRuleLifecycle(rule32, {
 var no_mixed_enums_default = deprecatedRule6;
 
 // dist/rules/no-negated-conditions.js
-var import_ts_extras27 = require("ts-extras");
+var import_ts_extras28 = require("ts-extras");
 var disallowedSelectors = [
   'IfStatement > BinaryExpression[operator="!=="]',
   'IfStatement > UnaryExpression[operator="!"]',
@@ -2439,9 +2525,9 @@ var disallowedSelectors = [
   ':not(LogicalExpression) > LogicalExpression[operator="||"] > BinaryExpression[operator="!=="]',
   ':not(LogicalExpression) > LogicalExpression[operator="||"] > UnaryExpression[operator="!"]'
 ];
-var rule33 = ruleCreator({
+var rule34 = ruleCreator({
   create: (context) => ({
-    [(0, import_ts_extras27.arrayJoin)(disallowedSelectors, ", ")]: (node) => {
+    [(0, import_ts_extras28.arrayJoin)(disallowedSelectors, ", ")]: (node) => {
       context.report({
         messageId: "forbidden",
         node
@@ -2466,18 +2552,18 @@ var rule33 = ruleCreator({
   },
   name: "no-negated-conditions"
 });
-var no_negated_conditions_default = rule33;
+var no_negated_conditions_default = rule34;
 
 // dist/rules/no-nodejs-modules.js
-var rule34 = createImportPatternRule({
+var rule35 = createImportPatternRule({
   defaultDisallowPatterns: ["node:*"],
   description: "disallow imports from node: built-in module specifiers.",
   name: "no-nodejs-modules"
 });
-var no_nodejs_modules_default = rule34;
+var no_nodejs_modules_default = rule35;
 
 // dist/rules/no-param-reassign.js
-var import_ts_extras28 = require("ts-extras");
+var import_ts_extras29 = require("ts-extras");
 var getAssignmentTargetIdentifier = (node) => {
   if (node.left.type === "Identifier") {
     return node.left;
@@ -2516,9 +2602,9 @@ var isInFirstFunctionExpressionStatement = (sourceCode, node) => {
   if (firstStatement?.type !== "ExpressionStatement") {
     return false;
   }
-  return (0, import_ts_extras28.arrayFirst)(node.range) >= (0, import_ts_extras28.arrayFirst)(firstStatement.range) && node.range[1] <= firstStatement.range[1];
+  return (0, import_ts_extras29.arrayFirst)(node.range) >= (0, import_ts_extras29.arrayFirst)(firstStatement.range) && node.range[1] <= firstStatement.range[1];
 };
-var rule35 = ruleCreator({
+var rule36 = ruleCreator({
   create: (context) => {
     const { sourceCode } = context;
     const reportIfParameterReassignment = (identifier) => {
@@ -2568,10 +2654,10 @@ var rule35 = ruleCreator({
   },
   name: "no-param-reassign"
 });
-var no_param_reassign_default = rule35;
+var no_param_reassign_default = rule36;
 
 // dist/rules/no-relative-parent-import.js
-var rule36 = createImportPatternRule({
+var rule37 = createImportPatternRule({
   defaultDisallowPatterns: [
     "..",
     "../**",
@@ -2587,7 +2673,7 @@ var rule36 = createImportPatternRule({
   description: "disallow relative parent imports.",
   name: "no-relative-parent-import"
 });
-var deprecatedRule7 = withDeprecatedRuleLifecycle(rule36, {
+var deprecatedRule7 = withDeprecatedRuleLifecycle(rule37, {
   message: "Deprecated in favor of import/no-relative-parent-imports.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -2606,14 +2692,14 @@ var deprecatedRule7 = withDeprecatedRuleLifecycle(rule36, {
 var no_relative_parent_import_default = deprecatedRule7;
 
 // dist/rules/no-restricted-syntax.js
-var import_ts_extras30 = require("ts-extras");
+var import_ts_extras31 = require("ts-extras");
 
 // dist/_internal/syntax-selectors.js
-var import_ts_extras29 = require("ts-extras");
-var isSelectorObject = (value) => typeof value === "object" && value !== null && (0, import_ts_extras29.keyIn)(value, "selector");
+var import_ts_extras30 = require("ts-extras");
+var isSelectorObject = (value) => typeof value === "object" && value !== null && (0, import_ts_extras30.keyIn)(value, "selector");
 var normalizeSyntaxSelector = (selector25) => {
   if (isSelectorObject(selector25)) {
-    if (!(0, import_ts_extras29.isDefined)(selector25.message)) {
+    if (!(0, import_ts_extras30.isDefined)(selector25.message)) {
       return {
         selector: selector25.selector
       };
@@ -2638,12 +2724,12 @@ var buildRestrictedSyntaxListeners = (entries, report) => {
 };
 
 // dist/rules/no-restricted-syntax.js
-var rule37 = ruleCreator({
+var rule38 = ruleCreator({
   create: (context, [options]) => {
     const selectors = options.selectors ?? [];
     const entries = selectors.map((selector25) => normalizeSyntaxSelector(selector25));
     return buildRestrictedSyntaxListeners(entries, (node, entry) => {
-      if ((0, import_ts_extras30.isDefined)(entry.message)) {
+      if ((0, import_ts_extras31.isDefined)(entry.message)) {
         context.report({
           data: {
             message: entry.message
@@ -2714,7 +2800,7 @@ var rule37 = ruleCreator({
   },
   name: "no-restricted-syntax"
 });
-var deprecatedRule8 = withDeprecatedRuleLifecycle(rule37, {
+var deprecatedRule8 = withDeprecatedRuleLifecycle(rule38, {
   message: "Deprecated in favor of ESLint core no-restricted-syntax.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -2730,8 +2816,8 @@ var no_restricted_syntax_default = deprecatedRule8;
 
 // dist/rules/no-secret.js
 var import_eslint_plugin_no_secrets = __toESM(require("eslint-plugin-no-secrets"), 1);
-var rule38 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_no_secrets.default, "no-secrets", "eslint-plugin-no-secrets"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-secret");
-var deprecatedRule9 = withDeprecatedRuleLifecycle(rule38, {
+var rule39 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_no_secrets.default, "no-secrets", "eslint-plugin-no-secrets"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-secret");
+var deprecatedRule9 = withDeprecatedRuleLifecycle(rule39, {
   message: "Deprecated in favor of dedicated secret scanning tools such as Secretlint and detect-secrets.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -2763,7 +2849,7 @@ var no_secret_default = deprecatedRule9;
 
 // dist/rules/no-self-import.js
 var import_node_path4 = require("node:path");
-var import_ts_extras31 = require("ts-extras");
+var import_ts_extras32 = require("ts-extras");
 var importFileSuffixes = [
   "",
   ".ts",
@@ -2779,7 +2865,7 @@ var importFileSuffixes = [
   "/index.cjs"
 ];
 var toResolvedCandidates = (baseDirectory, importSource) => importFileSuffixes.map((suffix) => (0, import_node_path4.resolve)(baseDirectory, `${importSource}${suffix}`));
-var rule39 = ruleCreator({
+var rule40 = ruleCreator({
   create: (context) => {
     const currentFilePath = context.filename;
     if (currentFilePath === "<input>") {
@@ -2794,7 +2880,7 @@ var rule39 = ruleCreator({
           return;
         }
         const candidatePaths = toResolvedCandidates(currentFileDirectory, sourceText);
-        if ((0, import_ts_extras31.arrayIncludes)(candidatePaths, normalizedCurrentFilePath)) {
+        if ((0, import_ts_extras32.arrayIncludes)(candidatePaths, normalizedCurrentFilePath)) {
           context.report({
             messageId: "forbidden",
             node
@@ -2821,7 +2907,7 @@ var rule39 = ruleCreator({
   },
   name: "no-self-import"
 });
-var deprecatedRule10 = withDeprecatedRuleLifecycle(rule39, {
+var deprecatedRule10 = withDeprecatedRuleLifecycle(rule40, {
   message: "Deprecated in favor of import/no-self-import.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -2856,7 +2942,7 @@ var collectScopes = (scope) => [
   scope,
   ...scope.childScopes.flatMap((childScope) => collectScopes(childScope))
 ];
-var rule40 = ruleCreator({
+var rule41 = ruleCreator({
   create: (context) => ({
     "Program:exit": (node) => {
       const programScope = context.sourceCode.getScope(node);
@@ -2902,7 +2988,7 @@ var rule40 = ruleCreator({
   },
   name: "no-shadow"
 });
-var deprecatedRule11 = withDeprecatedRuleLifecycle(rule40, {
+var deprecatedRule11 = withDeprecatedRuleLifecycle(rule41, {
   message: "Deprecated in favor of @typescript-eslint/no-shadow.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -2921,12 +3007,12 @@ var deprecatedRule11 = withDeprecatedRuleLifecycle(rule40, {
 var no_shadow_default = deprecatedRule11;
 
 // dist/rules/no-sibling-import.js
-var rule41 = createImportPatternRule({
+var rule42 = createImportPatternRule({
   defaultDisallowPatterns: ["./*"],
   description: "disallow sibling imports from the current directory.",
   name: "no-sibling-import"
 });
-var no_sibling_import_default = rule41;
+var no_sibling_import_default = rule42;
 
 // dist/rules/no-single-line-comment.js
 var directiveCommentPattern = /^(?:eslint(?:-|$)|global\s|exported\s|ts-(?:check|expect-error|ignore|nocheck))/u;
@@ -2937,7 +3023,7 @@ var createConvertToBlockSuggestionFix = (commentValue, commentRange) => {
   }
   return (fixer) => fixer.replaceTextRange(commentRange, `/*${commentValue} */`);
 };
-var rule42 = ruleCreator({
+var rule43 = ruleCreator({
   create: (context) => {
     const [{ allowDirectiveComments = true } = {}] = context.options;
     return {
@@ -3003,11 +3089,11 @@ var rule42 = ruleCreator({
   },
   name: "no-single-line-comment"
 });
-var no_single_line_comment_default = rule42;
+var no_single_line_comment_default = rule43;
 
 // dist/rules/no-t.js
 var defaultOptions7 = [{}];
-var rule43 = ruleCreator({
+var rule44 = ruleCreator({
   create: (context) => {
     const [{ prefix = "" } = {}] = context.options;
     return {
@@ -3062,16 +3148,16 @@ var rule43 = ruleCreator({
   },
   name: "no-t"
 });
-var no_t_default = rule43;
+var no_t_default = rule44;
 
 // dist/rules/no-underscore-export.js
-var import_ts_extras32 = require("ts-extras");
-var disallowedSelector6 = (0, import_ts_extras32.arrayJoin)([
+var import_ts_extras33 = require("ts-extras");
+var disallowedSelector6 = (0, import_ts_extras33.arrayJoin)([
   "ExportNamedDeclaration > FunctionDeclaration > Identifier.id[name=/^_/u]",
   "ExportNamedDeclaration > TSDeclareFunction > Identifier.id[name=/^_/u]",
   "ExportNamedDeclaration > VariableDeclaration > VariableDeclarator > Identifier.id[name=/^_/u]"
 ], ", ");
-var rule44 = ruleCreator({
+var rule45 = ruleCreator({
   create: (context) => ({
     [disallowedSelector6]: (node) => {
       context.report({
@@ -3098,7 +3184,7 @@ var rule44 = ruleCreator({
   },
   name: "no-underscore-export"
 });
-var no_underscore_export_default = rule44;
+var no_underscore_export_default = rule45;
 
 // dist/rules/no-unnecessary-as-const.js
 var disallowedSelector7 = "VariableDeclarator > TSAsExpression[expression.properties.length=0] > TSTypeReference > Identifier[name='const'], VariableDeclarator[id.typeAnnotation] > TSAsExpression > TSTypeReference > Identifier[name='const']";
@@ -3108,7 +3194,7 @@ var getAsConstExpression = (node) => {
   }
   return node.parent.parent;
 };
-var rule45 = ruleCreator({
+var rule46 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -3145,27 +3231,27 @@ var rule45 = ruleCreator({
   },
   name: "no-unnecessary-as-const"
 });
-var no_unnecessary_as_const_default = rule45;
+var no_unnecessary_as_const_default = rule46;
 
 // dist/rules/no-unnecessary-break.js
-var import_ts_extras33 = require("ts-extras");
+var import_ts_extras34 = require("ts-extras");
 var disallowedSelector8 = "SwitchCase:last-child > BreakStatement.consequent";
 var createTrailingBreakRemovalFix = (sourceCode, node) => {
   const previousToken = sourceCode.getTokenBefore(node);
   const previousTokenLine = previousToken?.loc.end.line;
   const breakLine = node.loc.start.line;
-  const shouldRemoveLeadingWhitespace = (0, import_ts_extras33.isDefined)(previousTokenLine) && previousTokenLine === breakLine;
+  const shouldRemoveLeadingWhitespace = (0, import_ts_extras34.isDefined)(previousTokenLine) && previousTokenLine === breakLine;
   if (previousToken === null || !shouldRemoveLeadingWhitespace) {
     return (fixer) => fixer.remove(node);
   }
-  const leadingText = sourceCode.text.slice(previousToken.range[1], (0, import_ts_extras33.arrayFirst)(node.range));
+  const leadingText = sourceCode.text.slice(previousToken.range[1], (0, import_ts_extras34.arrayFirst)(node.range));
   const leadingWhitespaceLength = /^[\t ]*/u.exec(leadingText)?.[0].length ?? 0;
   return (fixer) => fixer.removeRange([
-    (0, import_ts_extras33.arrayFirst)(node.range) - leadingWhitespaceLength,
+    (0, import_ts_extras34.arrayFirst)(node.range) - leadingWhitespaceLength,
     node.range[1]
   ]);
 };
-var rule46 = ruleCreator({
+var rule47 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -3208,10 +3294,10 @@ var rule46 = ruleCreator({
   },
   name: "no-unnecessary-break"
 });
-var no_unnecessary_break_default = rule46;
+var no_unnecessary_break_default = rule47;
 
 // dist/rules/no-unnecessary-initialization.js
-var import_ts_extras34 = require("ts-extras");
+var import_ts_extras35 = require("ts-extras");
 var disallowedSelector9 = "PropertyDefinition > Identifier.value[name='undefined'], VariableDeclarator > Identifier.init[name='undefined']";
 var getUndefinedInitializationRemovalRange = (sourceCode, node) => {
   const equalsToken = sourceCode.getTokenBefore(node, {
@@ -3220,7 +3306,7 @@ var getUndefinedInitializationRemovalRange = (sourceCode, node) => {
   if (equalsToken === null) {
     return void 0;
   }
-  let fixStartIndex = (0, import_ts_extras34.arrayFirst)(equalsToken.range);
+  let fixStartIndex = (0, import_ts_extras35.arrayFirst)(equalsToken.range);
   const sourceText = sourceCode.text;
   while (fixStartIndex > 0) {
     const previousCharacter = sourceText.at(fixStartIndex - 1);
@@ -3231,13 +3317,13 @@ var getUndefinedInitializationRemovalRange = (sourceCode, node) => {
   }
   return [fixStartIndex, node.range[1]];
 };
-var rule47 = ruleCreator({
+var rule48 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
       [disallowedSelector9]: (node) => {
         const removalRange = getUndefinedInitializationRemovalRange(sourceCode, node);
-        if (!(0, import_ts_extras34.isDefined)(removalRange)) {
+        if (!(0, import_ts_extras35.isDefined)(removalRange)) {
           return;
         }
         const fix = (fixer) => fixer.removeRange(removalRange);
@@ -3268,13 +3354,13 @@ var rule47 = ruleCreator({
   },
   name: "no-unnecessary-initialization"
 });
-var no_unnecessary_initialization_default = rule47;
+var no_unnecessary_initialization_default = rule48;
 
 // dist/rules/no-unnecessary-template-literal.js
-var import_ts_extras35 = require("ts-extras");
+var import_ts_extras36 = require("ts-extras");
 var selector3 = "TemplateLiteral[expressions.length=0] > TemplateElement";
-var toSafeStringLiteralText = (templateLiteral) => JSON.stringify((0, import_ts_extras35.arrayFirst)(templateLiteral.quasis)?.value.cooked ?? (0, import_ts_extras35.arrayFirst)(templateLiteral.quasis)?.value.raw ?? "");
-var rule48 = ruleCreator({
+var toSafeStringLiteralText = (templateLiteral) => JSON.stringify((0, import_ts_extras36.arrayFirst)(templateLiteral.quasis)?.value.cooked ?? (0, import_ts_extras36.arrayFirst)(templateLiteral.quasis)?.value.raw ?? "");
+var rule49 = ruleCreator({
   create: (context) => ({
     [selector3]: (node) => {
       const templateLiteral = node.type === "TemplateElement" && node.parent?.type === "TemplateLiteral" ? node.parent : void 0;
@@ -3307,12 +3393,12 @@ var rule48 = ruleCreator({
   },
   name: "no-unnecessary-template-literal"
 });
-var no_unnecessary_template_literal_default = rule48;
+var no_unnecessary_template_literal_default = rule49;
 
 // dist/rules/no-unused-disable.js
 var import_eslint_plugin_eslint_comments = __toESM(require("@eslint-community/eslint-plugin-eslint-comments"), 1);
-var rule49 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_eslint_comments.default, "no-unused-disable", "@eslint-community/eslint-plugin-eslint-comments"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-unused-disable");
-var deprecatedRule12 = withDeprecatedRuleLifecycle(rule49, {
+var rule50 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_eslint_comments.default, "no-unused-disable", "@eslint-community/eslint-plugin-eslint-comments"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-unused-disable");
+var deprecatedRule12 = withDeprecatedRuleLifecycle(rule50, {
   message: "Deprecated in favor of @eslint-community/eslint-comments/no-unused-disable.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -3330,10 +3416,296 @@ var deprecatedRule12 = withDeprecatedRuleLifecycle(rule49, {
 });
 var no_unused_disable_default = deprecatedRule12;
 
+// dist/rules/no-use-extend-native.js
+var import_ts_extras37 = require("ts-extras");
+var nativeTypeDefinitions = [
+  {
+    constructorRef: Array,
+    dataProperties: ["length"],
+    name: "Array",
+    prototypeRef: Array.prototype
+  },
+  {
+    constructorRef: BigInt,
+    name: "BigInt",
+    prototypeRef: BigInt.prototype
+  },
+  {
+    constructorRef: Boolean,
+    name: "Boolean",
+    prototypeRef: Boolean.prototype
+  },
+  {
+    constructorRef: Date,
+    name: "Date",
+    prototypeRef: Date.prototype
+  },
+  {
+    constructorRef: Error,
+    name: "Error",
+    prototypeRef: Error.prototype
+  },
+  {
+    constructorRef: Function,
+    name: "Function",
+    prototypeRef: Function.prototype
+  },
+  {
+    constructorRef: Map,
+    name: "Map",
+    prototypeRef: Map.prototype
+  },
+  {
+    constructorRef: Number,
+    name: "Number",
+    prototypeRef: Number.prototype
+  },
+  {
+    constructorRef: Object,
+    name: "Object",
+    prototypeRef: Object.prototype
+  },
+  {
+    constructorRef: Promise,
+    name: "Promise",
+    prototypeRef: Promise.prototype
+  },
+  {
+    constructorRef: RegExp,
+    dataProperties: ["lastIndex"],
+    name: "RegExp",
+    prototypeRef: RegExp.prototype
+  },
+  {
+    constructorRef: Set,
+    name: "Set",
+    prototypeRef: Set.prototype
+  },
+  {
+    constructorRef: String,
+    dataProperties: ["length"],
+    name: "String",
+    prototypeRef: String.prototype
+  },
+  {
+    constructorRef: Symbol,
+    name: "Symbol",
+    prototypeRef: Symbol.prototype
+  },
+  {
+    constructorRef: WeakMap,
+    name: "WeakMap",
+    prototypeRef: WeakMap.prototype
+  },
+  {
+    constructorRef: WeakSet,
+    name: "WeakSet",
+    prototypeRef: WeakSet.prototype
+  }
+];
+var nativeTypeNameSet = new Set(nativeTypeDefinitions.map((definition) => definition.name));
+function buildNativeTypeInfoByName(definitions) {
+  return new Map(definitions.map((definition) => [
+    definition.name,
+    {
+      propertyKinds: collectPropertyKinds(definition)
+    }
+  ]));
+}
+function collectPropertyKinds(definition) {
+  const propertyKinds = /* @__PURE__ */ new Map();
+  const descriptorSources = [
+    definition.prototypeRef,
+    definition.constructorRef
+  ];
+  for (const descriptorSource of descriptorSources) {
+    if (!(0, import_ts_extras37.isDefined)(descriptorSource)) {
+      continue;
+    }
+    const ownPropertyNames = Object.getOwnPropertyNames(descriptorSource);
+    for (const propertyName of ownPropertyNames) {
+      if (propertyKinds.has(propertyName)) {
+        continue;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(descriptorSource, propertyName);
+      if (!(0, import_ts_extras37.isDefined)(descriptor)) {
+        continue;
+      }
+      propertyKinds.set(propertyName, getMemberKind(descriptor));
+    }
+  }
+  for (const dataPropertyName of definition.dataProperties ?? []) {
+    if (!propertyKinds.has(dataPropertyName)) {
+      propertyKinds.set(dataPropertyName, "data");
+    }
+  }
+  return propertyKinds;
+}
+function unwrapExpression(node) {
+  if (node.type === "TSAsExpression" || node.type === "TSTypeAssertion") {
+    return unwrapExpression(node.expression);
+  }
+  if (node.type === "ChainExpression") {
+    return unwrapExpression(node.expression);
+  }
+  return node;
+}
+var inferNativeType = (rawExpression) => {
+  const expression = unwrapExpression(rawExpression);
+  if (expression.type === "ArrayExpression") {
+    return "Array";
+  }
+  if (expression.type === "ObjectExpression") {
+    return "Object";
+  }
+  if (expression.type === "TemplateLiteral") {
+    return "String";
+  }
+  if (expression.type === "Literal") {
+    return inferNativeTypeFromLiteral(expression);
+  }
+  if (expression.type === "Identifier" && isNativeTypeName(expression.name)) {
+    return expression.name;
+  }
+  if (expression.type === "BinaryExpression") {
+    return inferNativeTypeFromBinaryExpression(expression);
+  }
+  if (expression.type === "MemberExpression") {
+    return inferNativeTypeFromMemberExpression(expression);
+  }
+  if (expression.type === "NewExpression") {
+    return inferNativeTypeFromNewExpression(expression);
+  }
+  return null;
+};
+function inferNativeTypeFromBinaryExpression(expression) {
+  if (expression.operator !== "+") {
+    return null;
+  }
+  const leftType = inferNativeType(expression.left);
+  const rightType = inferNativeType(expression.right);
+  if (leftType === "String" || rightType === "String") {
+    return "String";
+  }
+  if (leftType === "RegExp" && rightType === "RegExp") {
+    return "String";
+  }
+  return null;
+}
+function inferNativeTypeFromLiteral(expression) {
+  if (typeof expression.value === "string") {
+    return "String";
+  }
+  if (typeof expression.value === "number") {
+    return "Number";
+  }
+  if (typeof expression.value === "boolean") {
+    return "Boolean";
+  }
+  if (typeof expression.value === "bigint") {
+    return "BigInt";
+  }
+  if (expression.value instanceof RegExp) {
+    return "RegExp";
+  }
+  return null;
+}
+function inferNativeTypeFromMemberExpression(expression) {
+  if (expression.computed || expression.property.type !== "Identifier" || expression.property.name !== "prototype" || expression.object.type !== "Identifier" || !isNativeTypeName(expression.object.name)) {
+    return null;
+  }
+  return expression.object.name;
+}
+function inferNativeTypeFromNewExpression(expression) {
+  if (expression.callee.type !== "Identifier" || !isNativeTypeName(expression.callee.name)) {
+    return null;
+  }
+  return expression.callee.name;
+}
+function getMemberKind(descriptor) {
+  if (typeof descriptor.value === "function") {
+    return "method";
+  }
+  if ((0, import_ts_extras37.isDefined)(descriptor.get) || (0, import_ts_extras37.isDefined)(descriptor.set)) {
+    return "accessor";
+  }
+  return "data";
+}
+var getStaticMemberPropertyName = (node) => {
+  if (node.computed || node.property.type !== "Identifier") {
+    return null;
+  }
+  return node.property.name;
+};
+var isCallUsage = (node) => {
+  const parent = node.parent;
+  return parent.type === "CallExpression" && parent.callee === node;
+};
+var nativeTypeInfoByName = buildNativeTypeInfoByName(nativeTypeDefinitions);
+var isNativeTypeName = (value) => (0, import_ts_extras37.setHas)(nativeTypeNameSet, value);
+var rule51 = ruleCreator({
+  create: (context) => ({
+    MemberExpression: (node) => {
+      const propertyName = getStaticMemberPropertyName(node);
+      if (propertyName === null || propertyName === "prototype") {
+        return;
+      }
+      const nativeTypeName = inferNativeType(node.object);
+      if (nativeTypeName === null) {
+        return;
+      }
+      const nativeTypeInfo = nativeTypeInfoByName.get(nativeTypeName);
+      if (!(0, import_ts_extras37.isDefined)(nativeTypeInfo)) {
+        return;
+      }
+      const memberKind = nativeTypeInfo.propertyKinds.get(propertyName);
+      if (!(0, import_ts_extras37.isDefined)(memberKind)) {
+        context.report({
+          data: {
+            nativeTypeName,
+            propertyName
+          },
+          messageId: "forbidden",
+          node
+        });
+        return;
+      }
+      if (isCallUsage(node) && memberKind !== "method") {
+        context.report({
+          data: {
+            nativeTypeName,
+            propertyName
+          },
+          messageId: "forbidden",
+          node
+        });
+      }
+    }
+  }),
+  meta: {
+    deprecated: false,
+    docs: {
+      deprecated: false,
+      description: "disallow usage of non-native members on built-in JavaScript objects.",
+      frozen: false,
+      recommended: false,
+      url: "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-use-extend-native"
+    },
+    hasSuggestions: false,
+    messages: {
+      forbidden: "Avoid using '{{nativeTypeName}}.{{propertyName}}' when it is not part of the native JavaScript API."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-use-extend-native"
+});
+var no_use_extend_native_default = rule51;
+
 // dist/rules/no-useless-generics.js
 var import_eslint_plugin3 = __toESM(require("@typescript-eslint/eslint-plugin"), 1);
-var rule50 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin3.default, "no-unnecessary-type-parameters", "@typescript-eslint/eslint-plugin"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-useless-generics");
-var deprecatedRule13 = withDeprecatedRuleLifecycle(rule50, {
+var rule52 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin3.default, "no-unnecessary-type-parameters", "@typescript-eslint/eslint-plugin"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-useless-generics");
+var deprecatedRule13 = withDeprecatedRuleLifecycle(rule52, {
   message: "Deprecated in favor of @typescript-eslint/no-unnecessary-type-parameters.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -3353,8 +3725,8 @@ var no_useless_generics_default = deprecatedRule13;
 
 // dist/rules/no-value-tostring.js
 var import_eslint_plugin4 = __toESM(require("@typescript-eslint/eslint-plugin"), 1);
-var rule51 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin4.default, "no-base-to-string", "@typescript-eslint/eslint-plugin"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-value-tostring");
-var deprecatedRule14 = withDeprecatedRuleLifecycle(rule51, {
+var rule53 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin4.default, "no-base-to-string", "@typescript-eslint/eslint-plugin"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-value-tostring");
+var deprecatedRule14 = withDeprecatedRuleLifecycle(rule53, {
   message: "Deprecated in favor of @typescript-eslint/no-base-to-string.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -3370,16 +3742,191 @@ var deprecatedRule14 = withDeprecatedRuleLifecycle(rule51, {
   ],
   ruleId: "no-value-tostring"
 });
-var no_value_tostring_default = deprecatedRule14;
+var no_value_tostring_default = deprecatedRule14;
+
+// dist/rules/no-vulnerable.js
+var import_recheck = require("recheck");
+var import_ts_extras38 = require("ts-extras");
+var getStaticStringValue = (node) => {
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis.length === 1) {
+    return (0, import_ts_extras38.arrayFirst)(node.quasis)?.value.cooked ?? null;
+  }
+  return null;
+};
+var isNonSpreadArgument = (argument) => argument.type !== "SpreadElement";
+var isRegExpConstructorCall = (node) => {
+  if (node.callee.type !== "Identifier" || node.callee.name !== "RegExp") {
+    return false;
+  }
+  if (node.arguments.length === 0 || node.arguments.length > 2) {
+    return false;
+  }
+  const sourceArgument = (0, import_ts_extras38.arrayFirst)(node.arguments);
+  if (!(0, import_ts_extras38.isDefined)(sourceArgument) || !isNonSpreadArgument(sourceArgument)) {
+    return false;
+  }
+  const sourceValue = getStaticStringValue(sourceArgument);
+  if (sourceValue === null) {
+    return false;
+  }
+  const flagsArgument = node.arguments[1];
+  if (flagsArgument === void 0) {
+    return true;
+  }
+  if (flagsArgument.type === "SpreadElement") {
+    return false;
+  }
+  return (0, import_ts_extras38.isDefined)(getStaticStringValue(flagsArgument));
+};
+var getStaticFlagsValue = (argument) => {
+  if (!(0, import_ts_extras38.isDefined)(argument)) {
+    return "";
+  }
+  if (!isNonSpreadArgument(argument)) {
+    return null;
+  }
+  return getStaticStringValue(argument);
+};
+var getDiagnosticsErrorMessage = (error) => {
+  if ((0, import_ts_extras38.keyIn)(error, "message") && typeof error.message === "string") {
+    return error.message;
+  }
+  return "No additional details provided.";
+};
+var rule54 = ruleCreator({
+  create: (context, [rawOptions]) => {
+    const options = rawOptions ?? {};
+    const { ignoreErrors = true, permittableComplexities = [], ...recheckParameters } = options;
+    const allowedComplexities = new Set(permittableComplexities);
+    const reportDiagnostics = (node, source, flags) => {
+      const diagnostics = (0, import_recheck.checkSync)(source, flags, recheckParameters);
+      if (diagnostics.status === "safe") {
+        return;
+      }
+      if (diagnostics.status === "vulnerable") {
+        if ((0, import_ts_extras38.setHas)(allowedComplexities, diagnostics.complexity.type)) {
+          return;
+        }
+        context.report({
+          data: {
+            summary: diagnostics.complexity.summary
+          },
+          messageId: "vulnerable",
+          node
+        });
+        return;
+      }
+      if (ignoreErrors) {
+        return;
+      }
+      context.report({
+        data: {
+          kind: diagnostics.error.kind,
+          message: getDiagnosticsErrorMessage(diagnostics.error)
+        },
+        messageId: "checkerError",
+        node
+      });
+    };
+    return {
+      CallExpression: (node) => {
+        if (!isRegExpConstructorCall(node)) {
+          return;
+        }
+        const sourceArgument = (0, import_ts_extras38.arrayFirst)(node.arguments);
+        if (!(0, import_ts_extras38.isDefined)(sourceArgument) || !isNonSpreadArgument(sourceArgument)) {
+          return;
+        }
+        const source = getStaticStringValue(sourceArgument);
+        const secondArgument = node.arguments[1];
+        const flags = getStaticFlagsValue(secondArgument);
+        if (source === null || flags === null) {
+          return;
+        }
+        reportDiagnostics(node, source, flags);
+      },
+      Literal: (node) => {
+        if (!(node.value instanceof RegExp)) {
+          return;
+        }
+        reportDiagnostics(node, node.value.source, node.value.flags);
+      },
+      NewExpression: (node) => {
+        if (!isRegExpConstructorCall(node)) {
+          return;
+        }
+        const sourceArgument = (0, import_ts_extras38.arrayFirst)(node.arguments);
+        if (!(0, import_ts_extras38.isDefined)(sourceArgument) || !isNonSpreadArgument(sourceArgument)) {
+          return;
+        }
+        const source = getStaticStringValue(sourceArgument);
+        const secondArgument = node.arguments[1];
+        const flags = getStaticFlagsValue(secondArgument);
+        if (source === null || flags === null) {
+          return;
+        }
+        reportDiagnostics(node, source, flags);
+      }
+    };
+  },
+  meta: {
+    defaultOptions: [{}],
+    deprecated: false,
+    docs: {
+      deprecated: false,
+      description: "disallow ReDoS-vulnerable regular expressions.",
+      frozen: false,
+      recommended: true,
+      url: "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-vulnerable"
+    },
+    hasSuggestions: false,
+    messages: {
+      checkerError: "ReDoS analysis failed ({{kind}}): {{message}}. Consider setting ignoreErrors to true for this pattern.",
+      vulnerable: "Potential ReDoS-vulnerable regular expression detected ({{summary}})."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        description: "Configuration for ReDoS analysis, including recheck parameters and local rule behavior flags.",
+        properties: {
+          ignoreErrors: {
+            description: "Whether to suppress errors returned by the ReDoS analyzer.",
+            type: "boolean"
+          },
+          permittableComplexities: {
+            description: "List of vulnerable complexity categories to permit without reporting.",
+            items: {
+              enum: ["polynomial", "exponential"],
+              type: "string"
+            },
+            type: "array",
+            uniqueItems: true
+          },
+          timeout: {
+            description: "Maximum analysis time budget in milliseconds passed through to recheck.",
+            type: ["number", "null"]
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "no-vulnerable"
+});
+var no_vulnerable_default = rule54;
 
 // dist/rules/no-writeonly.js
 var externalRule2 = getCoreRule("accessor-pairs");
-var rule52 = adaptExternalRule(externalRule2, "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-writeonly");
-var no_writeonly_default = rule52;
+var rule55 = adaptExternalRule(externalRule2, "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/no-writeonly");
+var no_writeonly_default = rule55;
 
 // dist/rules/object-format.js
 var isSingleLine = (node) => node.loc.start.line === node.loc.end.line;
-var rule53 = ruleCreator({
+var rule56 = ruleCreator({
   create: (context, [options]) => ({
     ObjectExpression: (node) => {
       const maxProperties = options.maxProperties ?? 1;
@@ -3432,10 +3979,10 @@ var rule53 = ruleCreator({
   },
   name: "object-format"
 });
-var object_format_default = rule53;
+var object_format_default = rule56;
 
 // dist/rules/only-export-name.js
-var import_ts_extras36 = require("ts-extras");
+var import_ts_extras39 = require("ts-extras");
 var getExportedNames = (node) => {
   if (node.specifiers.length > 0) {
     return node.specifiers.filter((specifier) => specifier.type === "ExportSpecifier").flatMap((specifier) => {
@@ -3463,12 +4010,12 @@ var getExportedNames = (node) => {
   }
   return [];
 };
-var rule54 = ruleCreator({
+var rule57 = ruleCreator({
   create: (context, [options]) => {
     const allowedNames = new Set(options.names ?? ["default"]);
     return {
       ExportDefaultDeclaration: (node) => {
-        if ((0, import_ts_extras36.setHas)(allowedNames, "default")) {
+        if ((0, import_ts_extras39.setHas)(allowedNames, "default")) {
           return;
         }
         context.report({
@@ -3482,7 +4029,7 @@ var rule54 = ruleCreator({
       ExportNamedDeclaration: (node) => {
         const exportedNames = getExportedNames(node);
         for (const name of exportedNames) {
-          if ((0, import_ts_extras36.setHas)(allowedNames, name)) {
+          if ((0, import_ts_extras39.setHas)(allowedNames, name)) {
             continue;
           }
           context.report({
@@ -3532,11 +4079,11 @@ var rule54 = ruleCreator({
   },
   name: "only-export-name"
 });
-var only_export_name_default = rule54;
+var only_export_name_default = rule57;
 
 // dist/rules/prefer-arrow-function-property.js
 var disallowedSelector10 = "Property > FunctionExpression.value:not([params.0.name='this'])";
-var rule55 = ruleCreator({
+var rule58 = ruleCreator({
   create: (context) => ({
     [disallowedSelector10]: (node) => {
       context.report({
@@ -3563,11 +4110,11 @@ var rule55 = ruleCreator({
   },
   name: "prefer-arrow-function-property"
 });
-var prefer_arrow_function_property_default = rule55;
+var prefer_arrow_function_property_default = rule58;
 
 // dist/rules/prefer-const-require.js
 var disallowedSelector11 = ":not(VariableDeclarator) > CallExpression > Identifier.callee[name='require']";
-var rule56 = ruleCreator({
+var rule59 = ruleCreator({
   create: (context) => ({
     [disallowedSelector11]: (node) => {
       context.report({
@@ -3594,12 +4141,12 @@ var rule56 = ruleCreator({
   },
   name: "prefer-const-require"
 });
-var prefer_const_require_default = rule56;
+var prefer_const_require_default = rule59;
 
 // dist/rules/prefer-includes.js
 var import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
-var rule57 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_unicorn.default, "prefer-includes", "eslint-plugin-unicorn"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/prefer-includes");
-var deprecatedRule15 = withDeprecatedRuleLifecycle(rule57, {
+var rule60 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_unicorn.default, "prefer-includes", "eslint-plugin-unicorn"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/prefer-includes");
+var deprecatedRule15 = withDeprecatedRuleLifecycle(rule60, {
   message: "Deprecated in favor of unicorn/prefer-includes.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -3620,7 +4167,7 @@ var prefer_includes_default = deprecatedRule15;
 // dist/rules/prefer-interface.js
 var import_type_utils5 = require("@typescript-eslint/type-utils");
 var import_utils8 = require("@typescript-eslint/utils");
-var import_ts_extras37 = require("ts-extras");
+var import_ts_extras40 = require("ts-extras");
 var tsutils2 = __toESM(require("tsutils"), 1);
 var defaultOptions8 = [{}];
 var isExportedTypeAlias = (typeAliasDeclaration) => typeAliasDeclaration.parent?.type === "ExportNamedDeclaration" && typeAliasDeclaration.parent.declaration === typeAliasDeclaration;
@@ -3634,13 +4181,13 @@ var createTypeLiteralFixText = (sourceCode, typeAliasDeclaration, typeLiteralNod
 var createFunctionTypeFixText = (sourceCode, typeAliasDeclaration, functionTypeNode) => {
   const aliasTypeParameters = formatTypeParameters(sourceCode, typeAliasDeclaration.typeParameters);
   const functionTypeParameters = formatTypeParameters(sourceCode, functionTypeNode.typeParameters);
-  const parametersText = (0, import_ts_extras37.arrayJoin)(functionTypeNode.params.map((parameter) => sourceCode.getText(parameter)), ", ");
+  const parametersText = (0, import_ts_extras40.arrayJoin)(functionTypeNode.params.map((parameter) => sourceCode.getText(parameter)), ", ");
   const returnTypeText = functionTypeNode.returnType === void 0 ? "void" : sourceCode.getText(functionTypeNode.returnType.typeAnnotation);
   return `interface ${typeAliasDeclaration.id.name}${aliasTypeParameters} { ${functionTypeParameters}(${parametersText}): ${returnTypeText}; }`;
 };
 var createIntersectionFixText = (sourceCode, typeAliasDeclaration, literalNode, referenceNodes) => {
   const aliasTypeParameters = formatTypeParameters(sourceCode, typeAliasDeclaration.typeParameters);
-  const baseTypesText = (0, import_ts_extras37.arrayJoin)(referenceNodes.map((referenceNode) => sourceCode.getText(referenceNode)), ", ");
+  const baseTypesText = (0, import_ts_extras40.arrayJoin)(referenceNodes.map((referenceNode) => sourceCode.getText(referenceNode)), ", ");
   const extendsClause = baseTypesText.length > 0 ? ` extends ${baseTypesText}` : "";
   const bodyText = literalNode === void 0 ? "{}" : sourceCode.getText(literalNode);
   return `interface ${typeAliasDeclaration.id.name}${aliasTypeParameters}${extendsClause} ${bodyText}`;
@@ -3688,7 +4235,7 @@ var reportTypeAlias = (context, typeAliasDeclaration, replacementText) => {
     ]
   });
 };
-var rule58 = ruleCreator({
+var rule61 = ruleCreator({
   create: (context) => {
     const [{ allowIntersection = true, allowLocal = false } = {}] = context.options;
     const sourceCode = context.sourceCode;
@@ -3718,10 +4265,10 @@ var rule58 = ruleCreator({
           return;
         }
         const conversion = canSafelyConvertIntersection(intersectionTypeNode, typedParserServices);
-        if (!(0, import_ts_extras37.isDefined)(conversion)) {
+        if (!(0, import_ts_extras40.isDefined)(conversion)) {
           return;
         }
-        reportTypeAlias(context, typeAliasDeclaration, createIntersectionFixText(sourceCode, typeAliasDeclaration, (0, import_ts_extras37.arrayFirst)(conversion.literals), conversion.references));
+        reportTypeAlias(context, typeAliasDeclaration, createIntersectionFixText(sourceCode, typeAliasDeclaration, (0, import_ts_extras40.arrayFirst)(conversion.literals), conversion.references));
       },
       "TSTypeAliasDeclaration > TSTypeLiteral": (typeLiteralNode) => {
         const typeAliasDeclaration = getTypeAliasDeclarationParent(typeLiteralNode.parent);
@@ -3774,7 +4321,7 @@ var rule58 = ruleCreator({
   },
   name: "prefer-interface"
 });
-var deprecatedRule16 = withDeprecatedRuleLifecycle(rule58, {
+var deprecatedRule16 = withDeprecatedRuleLifecycle(rule61, {
   message: "Deprecated in favor of @typescript-eslint/consistent-type-definitions.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -3805,7 +4352,7 @@ var createFixes = (fixer, context, expression, operatorText) => {
     fixer.replaceText(right, context.sourceCode.getText(left))
   ];
 };
-var rule59 = ruleCreator({
+var rule62 = ruleCreator({
   create: (context) => ({
     "BinaryExpression[operator='>'], BinaryExpression[operator='>=']": (expression) => {
       const useLessThanOrEqual = expression.operator === ">=";
@@ -3847,12 +4394,12 @@ var rule59 = ruleCreator({
   },
   name: "prefer-less-than"
 });
-var prefer_less_than_default = rule59;
+var prefer_less_than_default = rule62;
 
 // dist/rules/prefer-object-has-own.js
 var externalRule3 = getCoreRule("prefer-object-has-own");
-var rule60 = adaptExternalRule(externalRule3, "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/prefer-object-has-own");
-var deprecatedRule17 = withDeprecatedRuleLifecycle(rule60, {
+var rule63 = adaptExternalRule(externalRule3, "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/prefer-object-has-own");
+var deprecatedRule17 = withDeprecatedRuleLifecycle(rule63, {
   message: "Deprecated in favor of ESLint core prefer-object-has-own.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -3872,7 +4419,7 @@ var prefer_object_has_own_default = deprecatedRule17;
 
 // dist/rules/prefer-only-export.js
 var selector4 = "Program[body.length>1]:has(ExportDefaultDeclaration)";
-var rule61 = ruleCreator({
+var rule64 = ruleCreator({
   create: (context) => ({
     [selector4]: (node) => {
       context.report({
@@ -3899,10 +4446,10 @@ var rule61 = ruleCreator({
   },
   name: "prefer-only-export"
 });
-var prefer_only_export_default = rule61;
+var prefer_only_export_default = rule64;
 
 // dist/rules/require-jsdoc.js
-var import_ts_extras38 = require("ts-extras");
+var import_ts_extras41 = require("ts-extras");
 var defaultKinds = [
   "arrow-function",
   "class",
@@ -3912,7 +4459,7 @@ var defaultKinds = [
 ];
 var hasJSDocComment = (sourceCode, node) => {
   const comments = sourceCode.getCommentsBefore(node);
-  const comment = (0, import_ts_extras38.arrayLast)(comments);
+  const comment = (0, import_ts_extras41.arrayLast)(comments);
   return comment?.type === "Block" && comment.value.startsWith("*");
 };
 var reportMissingJSDoc = (context, node) => {
@@ -3924,30 +4471,30 @@ var reportMissingJSDoc = (context, node) => {
     node
   });
 };
-var rule62 = ruleCreator({
+var rule65 = ruleCreator({
   create: (context, [options]) => {
     const kinds = new Set(options.kinds ?? defaultKinds);
     return {
       ClassDeclaration: (node) => {
-        if (!(0, import_ts_extras38.setHas)(kinds, "class") || node.id === null) {
+        if (!(0, import_ts_extras41.setHas)(kinds, "class") || node.id === null) {
           return;
         }
         reportMissingJSDoc(context, node);
       },
       FunctionDeclaration: (node) => {
-        if (!(0, import_ts_extras38.setHas)(kinds, "function") || node.id === null) {
+        if (!(0, import_ts_extras41.setHas)(kinds, "function") || node.id === null) {
           return;
         }
         reportMissingJSDoc(context, node);
       },
       MethodDefinition: (node) => {
-        if (!(0, import_ts_extras38.setHas)(kinds, "method") || node.kind === "constructor" || node.key.type !== "Identifier") {
+        if (!(0, import_ts_extras41.setHas)(kinds, "method") || node.kind === "constructor" || node.key.type !== "Identifier") {
           return;
         }
         reportMissingJSDoc(context, node);
       },
       "TSTypeAliasDeclaration, TSInterfaceDeclaration": (node) => {
-        if (!(0, import_ts_extras38.setHas)(kinds, "type")) {
+        if (!(0, import_ts_extras41.setHas)(kinds, "type")) {
           return;
         }
         if (node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration") {
@@ -3955,7 +4502,7 @@ var rule62 = ruleCreator({
         }
       },
       VariableDeclarator: (node) => {
-        if (!(0, import_ts_extras38.setHas)(kinds, "arrow-function") || node.id.type !== "Identifier" || node.init?.type !== "ArrowFunctionExpression" || node.parent.type !== "VariableDeclaration" || node.parent.kind !== "const") {
+        if (!(0, import_ts_extras41.setHas)(kinds, "arrow-function") || node.id.type !== "Identifier" || node.init?.type !== "ArrowFunctionExpression" || node.parent.type !== "VariableDeclaration" || node.parent.kind !== "const") {
           return;
         }
         reportMissingJSDoc(context, node.parent);
@@ -3997,7 +4544,7 @@ var rule62 = ruleCreator({
   },
   name: "require-jsdoc"
 });
-var deprecatedRule18 = withDeprecatedRuleLifecycle(rule62, {
+var deprecatedRule18 = withDeprecatedRuleLifecycle(rule65, {
   message: "Deprecated in favor of jsdoc/require-jsdoc.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -4016,8 +4563,8 @@ var deprecatedRule18 = withDeprecatedRuleLifecycle(rule62, {
 var require_jsdoc_default = deprecatedRule18;
 
 // dist/rules/require-syntax.js
-var import_ts_extras39 = require("ts-extras");
-var rule63 = ruleCreator({
+var import_ts_extras42 = require("ts-extras");
+var rule66 = ruleCreator({
   create: (context, [options]) => {
     const entries = (options.selectors ?? []).map((selector25) => normalizeSyntaxSelector(selector25));
     const counters = entries.map(() => 0);
@@ -4039,7 +4586,7 @@ var rule63 = ruleCreator({
           if (count > 0) {
             continue;
           }
-          if ((0, import_ts_extras39.isDefined)(entry.message)) {
+          if ((0, import_ts_extras42.isDefined)(entry.message)) {
             context.report({
               data: {
                 message: entry.message
@@ -4115,11 +4662,11 @@ var rule63 = ruleCreator({
   },
   name: "require-syntax"
 });
-var require_syntax_default = rule63;
+var require_syntax_default = rule66;
 
 // dist/rules/restrict-identifier-characters.js
 var disallowedSelector12 = String.raw`Identifier[name=/[^$\w]/u]`;
-var rule64 = ruleCreator({
+var rule67 = ruleCreator({
   create: (context) => ({
     [disallowedSelector12]: (node) => {
       context.report({
@@ -4146,10 +4693,10 @@ var rule64 = ruleCreator({
   },
   name: "restrict-identifier-characters"
 });
-var restrict_identifier_characters_default = rule64;
+var restrict_identifier_characters_default = rule67;
 
 // dist/rules/sort-array.js
-var import_ts_extras40 = require("ts-extras");
+var import_ts_extras43 = require("ts-extras");
 var getSortableValue = (element) => {
   if (element.type === "Literal") {
     return String(element.value);
@@ -4158,15 +4705,15 @@ var getSortableValue = (element) => {
 };
 var buildFix2 = (sourceCode, node, sorted) => (fixer) => {
   const [first, last] = [
-    (0, import_ts_extras40.arrayFirst)(node.elements),
-    (0, import_ts_extras40.arrayAt)(node.elements, -1)
+    (0, import_ts_extras43.arrayFirst)(node.elements),
+    (0, import_ts_extras43.arrayAt)(node.elements, -1)
   ];
-  if (!(0, import_ts_extras40.isPresent)(first) || !(0, import_ts_extras40.isPresent)(last)) {
+  if (!(0, import_ts_extras43.isPresent)(first) || !(0, import_ts_extras43.isPresent)(last)) {
     return fixer.replaceText(node, sourceCode.getText(node));
   }
-  return fixer.replaceTextRange([(0, import_ts_extras40.arrayFirst)(first.range), last.range[1]], (0, import_ts_extras40.arrayJoin)(sorted.map((element) => sourceCode.getText(element)), ", "));
+  return fixer.replaceTextRange([(0, import_ts_extras43.arrayFirst)(first.range), last.range[1]], (0, import_ts_extras43.arrayJoin)(sorted.map((element) => sourceCode.getText(element)), ", "));
 };
-var rule65 = ruleCreator({
+var rule68 = ruleCreator({
   create: (context) => ({
     ArrayExpression: (node) => {
       let elements = [];
@@ -4179,7 +4726,7 @@ var rule65 = ruleCreator({
         return;
       }
       const sortKeys = elements.map((element) => getSortableValue(element));
-      if (sortKeys.some((sortKey) => !(0, import_ts_extras40.isDefined)(sortKey))) {
+      if (sortKeys.some((sortKey) => !(0, import_ts_extras43.isDefined)(sortKey))) {
         return;
       }
       const sorted = [...elements].sort((a, b) => (getSortableValue(a) ?? "").localeCompare(getSortableValue(b) ?? ""));
@@ -4213,11 +4760,11 @@ var rule65 = ruleCreator({
   },
   name: "sort-array"
 });
-var sort_array_default = rule65;
+var sort_array_default = rule68;
 
 // dist/rules/sort-call-signature.js
 var disallowedSelector13 = "TSInterfaceBody > TSCallSignatureDeclaration:not(:first-child)";
-var rule66 = ruleCreator({
+var rule69 = ruleCreator({
   create: (context) => ({
     [disallowedSelector13]: (node) => {
       context.report({
@@ -4244,10 +4791,10 @@ var rule66 = ruleCreator({
   },
   name: "sort-call-signature"
 });
-var sort_call_signature_default = rule66;
+var sort_call_signature_default = rule69;
 
 // dist/rules/sort-class-members.js
-var import_ts_extras41 = require("ts-extras");
+var import_ts_extras44 = require("ts-extras");
 var memberName = (member) => {
   if (member.key.type === "Identifier") {
     return member.key.name;
@@ -4257,7 +4804,7 @@ var memberName = (member) => {
   }
   return void 0;
 };
-var rule67 = ruleCreator({
+var rule70 = ruleCreator({
   create: (context) => ({
     ClassBody: (node) => {
       let members = [];
@@ -4270,7 +4817,7 @@ var rule67 = ruleCreator({
       let hasPreviousName = false;
       for (const member of members) {
         const currentName = memberName(member);
-        if (!(0, import_ts_extras41.isDefined)(currentName)) {
+        if (!(0, import_ts_extras44.isDefined)(currentName)) {
           continue;
         }
         if (hasPreviousName && currentName.localeCompare(previousName) < 0) {
@@ -4303,7 +4850,7 @@ var rule67 = ruleCreator({
   },
   name: "sort-class-members"
 });
-var deprecatedRule19 = withDeprecatedRuleLifecycle(rule67, {
+var deprecatedRule19 = withDeprecatedRuleLifecycle(rule70, {
   message: "Deprecated in favor of sort-class-members/sort-class-members or perfectionist sorting rules.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -4329,7 +4876,7 @@ var sort_class_members_default = deprecatedRule19;
 
 // dist/rules/sort-construct-signature.js
 var disallowedSelector14 = "TSInterfaceBody > TSConstructSignatureDeclaration:not(:first-child)";
-var rule68 = ruleCreator({
+var rule71 = ruleCreator({
   create: (context) => ({
     [disallowedSelector14]: (node) => {
       context.report({
@@ -4356,17 +4903,17 @@ var rule68 = ruleCreator({
   },
   name: "sort-construct-signature"
 });
-var sort_construct_signature_default = rule68;
+var sort_construct_signature_default = rule71;
 
 // dist/rules/sort-export-specifiers.js
-var import_ts_extras42 = require("ts-extras");
+var import_ts_extras45 = require("ts-extras");
 var toName = (specifier) => specifier.exported.type === "Identifier" ? specifier.exported.name : specifier.exported.value;
 var buildFix3 = (fixer, node, sourceCode, sorted) => {
-  const startRange = (0, import_ts_extras42.arrayFirst)(node.specifiers)?.range ?? node.range;
-  const endRange = (0, import_ts_extras42.arrayLast)(node.specifiers)?.range ?? node.range;
-  return fixer.replaceTextRange([(0, import_ts_extras42.arrayFirst)(startRange), (0, import_ts_extras42.arrayLast)(endRange)], (0, import_ts_extras42.arrayJoin)(sorted.map((specifier) => sourceCode.getText(specifier)), ", "));
+  const startRange = (0, import_ts_extras45.arrayFirst)(node.specifiers)?.range ?? node.range;
+  const endRange = (0, import_ts_extras45.arrayLast)(node.specifiers)?.range ?? node.range;
+  return fixer.replaceTextRange([(0, import_ts_extras45.arrayFirst)(startRange), (0, import_ts_extras45.arrayLast)(endRange)], (0, import_ts_extras45.arrayJoin)(sorted.map((specifier) => sourceCode.getText(specifier)), ", "));
 };
-var rule69 = ruleCreator({
+var rule72 = ruleCreator({
   create: (context) => ({
     ExportNamedDeclaration: (node) => {
       let exportSpecifiers = [];
@@ -4409,10 +4956,10 @@ var rule69 = ruleCreator({
   },
   name: "sort-export-specifiers"
 });
-var sort_export_specifiers_default = rule69;
+var sort_export_specifiers_default = rule72;
 
 // dist/rules/sort-keys.js
-var import_ts_extras43 = require("ts-extras");
+var import_ts_extras46 = require("ts-extras");
 var keyName = (property) => {
   if (property.key.type === "Identifier") {
     return property.key.name;
@@ -4423,15 +4970,15 @@ var keyName = (property) => {
   return void 0;
 };
 var buildFix4 = (sourceCode, properties) => (fixer) => {
-  const first = (0, import_ts_extras43.arrayFirst)(properties);
-  const last = (0, import_ts_extras43.arrayLast)(properties);
+  const first = (0, import_ts_extras46.arrayFirst)(properties);
+  const last = (0, import_ts_extras46.arrayLast)(properties);
   if (first === void 0 || last === void 0) {
     return fixer.insertTextAfterRange([0, 0], "");
   }
   const sorted = [...properties].sort((a, b) => (keyName(a) ?? "").localeCompare(keyName(b) ?? ""));
-  return fixer.replaceTextRange([(0, import_ts_extras43.arrayFirst)(first.range), last.range[1]], (0, import_ts_extras43.arrayJoin)(sorted.map((property) => sourceCode.getText(property)), ", "));
+  return fixer.replaceTextRange([(0, import_ts_extras46.arrayFirst)(first.range), last.range[1]], (0, import_ts_extras46.arrayJoin)(sorted.map((property) => sourceCode.getText(property)), ", "));
 };
-var rule70 = ruleCreator({
+var rule73 = ruleCreator({
   create: (context) => ({
     ObjectExpression: (node) => {
       let properties = [];
@@ -4447,7 +4994,7 @@ var rule70 = ruleCreator({
       let hasPreviousName = false;
       for (const property of properties) {
         const currentName = keyName(property);
-        if (!(0, import_ts_extras43.isDefined)(currentName)) {
+        if (!(0, import_ts_extras46.isDefined)(currentName)) {
           return;
         }
         if (hasPreviousName && currentName.localeCompare(previousName) < 0) {
@@ -4482,16 +5029,16 @@ var rule70 = ruleCreator({
   },
   name: "sort-keys"
 });
-var sort_keys_default = rule70;
+var sort_keys_default = rule73;
 
 // dist/rules/sort-top-comments.js
-var import_ts_extras44 = require("ts-extras");
+var import_ts_extras47 = require("ts-extras");
 var commentText = (comment) => comment.value.trim();
-var buildReplacement = (sourceCode, comments) => (0, import_ts_extras44.arrayJoin)(comments.map((comment) => sourceCode.getText(comment)).sort((a, b) => a.localeCompare(b)), "\n");
-var rule71 = ruleCreator({
+var buildReplacement = (sourceCode, comments) => (0, import_ts_extras47.arrayJoin)(comments.map((comment) => sourceCode.getText(comment)).sort((a, b) => a.localeCompare(b)), "\n");
+var rule74 = ruleCreator({
   create: (context) => ({
     Program: (node) => {
-      const firstNode = (0, import_ts_extras44.arrayFirst)(node.body);
+      const firstNode = (0, import_ts_extras47.arrayFirst)(node.body);
       if (firstNode === void 0) {
         return;
       }
@@ -4499,18 +5046,18 @@ var rule71 = ruleCreator({
       if (comments.length < 2) {
         return;
       }
-      const firstComment = (0, import_ts_extras44.arrayFirst)(comments);
+      const firstComment = (0, import_ts_extras47.arrayFirst)(comments);
       if (firstComment === void 0) {
         return;
       }
-      const lastComment = (0, import_ts_extras44.arrayLast)(comments) ?? firstComment;
+      const lastComment = (0, import_ts_extras47.arrayLast)(comments) ?? firstComment;
       const sorted = [...comments].sort((a, b) => commentText(a).localeCompare(commentText(b)));
       const isSorted = comments.every((comment, index) => comment === sorted[index]);
       if (isSorted) {
         return;
       }
       context.report({
-        fix: (fixer) => fixer.replaceTextRange([(0, import_ts_extras44.arrayFirst)(firstComment.range), lastComment.range[1]], buildReplacement(context.sourceCode, comments)),
+        fix: (fixer) => fixer.replaceTextRange([(0, import_ts_extras47.arrayFirst)(firstComment.range), lastComment.range[1]], buildReplacement(context.sourceCode, comments)),
         messageId: "incorrectSorting",
         node: firstComment
       });
@@ -4535,16 +5082,16 @@ var rule71 = ruleCreator({
   },
   name: "sort-top-comments"
 });
-var sort_top_comments_default = rule71;
+var sort_top_comments_default = rule74;
 
 // dist/rules/switch-case-spacing.js
-var import_ts_extras45 = require("ts-extras");
+var import_ts_extras48 = require("ts-extras");
 var isValidCaseBody = (node) => {
   if (node.consequent.length === 0) {
     return true;
   }
   const [firstStatement] = node.consequent;
-  const lastStatement = (0, import_ts_extras45.arrayLast)(node.consequent);
+  const lastStatement = (0, import_ts_extras48.arrayLast)(node.consequent);
   if (firstStatement === void 0 || lastStatement === void 0) {
     return true;
   }
@@ -4553,7 +5100,7 @@ var isValidCaseBody = (node) => {
   const endsWithBreak = lastStatement.type === "BreakStatement" || startsWithBlock;
   return (startsOnFollowingLine || startsWithBlock) && endsWithBreak;
 };
-var rule72 = ruleCreator({
+var rule75 = ruleCreator({
   create: (context) => ({
     SwitchCase: (node) => {
       if (isValidCaseBody(node)) {
@@ -4583,7 +5130,7 @@ var rule72 = ruleCreator({
   },
   name: "switch-case-spacing"
 });
-var deprecatedRule20 = withDeprecatedRuleLifecycle(rule72, {
+var deprecatedRule20 = withDeprecatedRuleLifecycle(rule75, {
   message: "Deprecated in favor of @stylistic/switch-colon-spacing.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -4602,22 +5149,22 @@ var deprecatedRule20 = withDeprecatedRuleLifecycle(rule72, {
 var switch_case_spacing_default = deprecatedRule20;
 
 // dist/rules/template-literal-format.js
-var import_ts_extras46 = require("ts-extras");
+var import_ts_extras49 = require("ts-extras");
 var isMultilineTemplate = (node) => node.loc.start.line !== node.loc.end.line;
 var hasExpectedBoundaryNewlines = (node) => {
-  const first = (0, import_ts_extras46.arrayFirst)(node.quasis)?.value.raw ?? "";
-  const last = (0, import_ts_extras46.arrayLast)(node.quasis)?.value.raw ?? "";
+  const first = (0, import_ts_extras49.arrayFirst)(node.quasis)?.value.raw ?? "";
+  const last = (0, import_ts_extras49.arrayLast)(node.quasis)?.value.raw ?? "";
   return first.startsWith("\n") && last.endsWith("\n");
 };
 var normalizeTemplate = (sourceText) => {
-  const lines = (0, import_ts_extras46.stringSplit)(sourceText.replaceAll(/\r\n?/gu, "\n"), "\n");
+  const lines = (0, import_ts_extras49.stringSplit)(sourceText.replaceAll(/\r\n?/gu, "\n"), "\n");
   const contentLines = lines.slice(1, -1);
   const indents = contentLines.filter((line) => line.trim().length > 0).map((line) => /^\s*/u.exec(line)?.[0].length ?? 0);
-  const minIndent = (0, import_ts_extras46.isEmpty)(indents) ? 0 : Math.min(...indents);
-  const normalizedContent = (0, import_ts_extras46.arrayJoin)(contentLines.map((line) => line.length >= minIndent ? line.slice(minIndent) : line).map((line) => `  ${line}`), "\n");
-  const lastLine = (0, import_ts_extras46.arrayLast)(lines) ?? "";
-  return (0, import_ts_extras46.arrayJoin)([
-    (0, import_ts_extras46.arrayFirst)(lines),
+  const minIndent = (0, import_ts_extras49.isEmpty)(indents) ? 0 : Math.min(...indents);
+  const normalizedContent = (0, import_ts_extras49.arrayJoin)(contentLines.map((line) => line.length >= minIndent ? line.slice(minIndent) : line).map((line) => `  ${line}`), "\n");
+  const lastLine = (0, import_ts_extras49.arrayLast)(lines) ?? "";
+  return (0, import_ts_extras49.arrayJoin)([
+    (0, import_ts_extras49.arrayFirst)(lines),
     normalizedContent,
     lastLine
   ], "\n");
@@ -4626,7 +5173,7 @@ var buildFix5 = (sourceCode, node) => (fixer) => {
   const text = sourceCode.getText(node);
   return fixer.replaceText(node, normalizeTemplate(text));
 };
-var rule73 = ruleCreator({
+var rule76 = ruleCreator({
   create: (context) => ({
     TemplateLiteral: (node) => {
       if (!isMultilineTemplate(node) || hasExpectedBoundaryNewlines(node)) {
@@ -4658,12 +5205,12 @@ var rule73 = ruleCreator({
   },
   name: "template-literal-format"
 });
-var template_literal_format_default = rule73;
+var template_literal_format_default = rule76;
 
 // dist/rules/throw-error.js
 var import_type_utils6 = require("@typescript-eslint/type-utils");
 var import_utils9 = require("@typescript-eslint/utils");
-var import_ts_extras47 = require("ts-extras");
+var import_ts_extras50 = require("ts-extras");
 var tsutils3 = __toESM(require("tsutils"), 1);
 var isAllowedThrowableVariant = (type, program) => (0, import_type_utils6.isTypeAnyType)(type) || (0, import_type_utils6.isTypeUnknownType)(type) || (0, import_type_utils6.isErrorLike)(program, type);
 var couldBeAllowedThrowableType = (type, program) => tsutils3.unionTypeParts(type).every((typeVariant) => isAllowedThrowableVariant(typeVariant, program));
@@ -4675,7 +5222,7 @@ var createWrapLiteralInErrorSuggestionFix = (sourceCode, node) => {
   }
   return (fixer) => fixer.replaceText(node, `new Error(${sourceCode.getText(node)})`);
 };
-var rule74 = ruleCreator({
+var rule77 = ruleCreator({
   create: (context) => {
     const parserServices = import_utils9.ESLintUtils.getParserServices(context);
     const sourceCode = context.sourceCode;
@@ -4701,7 +5248,7 @@ var rule74 = ruleCreator({
       });
     };
     const checkRejectionCall = (callExpression) => {
-      const rejectionValue = (0, import_ts_extras47.arrayFirst)(callExpression.arguments);
+      const rejectionValue = (0, import_ts_extras50.arrayFirst)(callExpression.arguments);
       if (rejectionValue === void 0) {
         return;
       }
@@ -4724,8 +5271,8 @@ var rule74 = ruleCreator({
         if (rejectParameter?.type !== "Identifier") {
           return;
         }
-        const rejectVariable = (0, import_ts_extras47.arrayFirst)(context.sourceCode.getDeclaredVariables(callback).filter((declaredVariable) => declaredVariable.name === rejectParameter.name));
-        if (!(0, import_ts_extras47.isDefined)(rejectVariable)) {
+        const rejectVariable = (0, import_ts_extras50.arrayFirst)(context.sourceCode.getDeclaredVariables(callback).filter((declaredVariable) => declaredVariable.name === rejectParameter.name));
+        if (!(0, import_ts_extras50.isDefined)(rejectVariable)) {
           return;
         }
         for (const reference of rejectVariable.references) {
@@ -4765,12 +5312,12 @@ var rule74 = ruleCreator({
   },
   name: "throw-error"
 });
-var throw_error_default = rule74;
+var throw_error_default = rule77;
 
 // dist/rules/throw-new-error.js
 var import_eslint_plugin_unicorn2 = __toESM(require("eslint-plugin-unicorn"), 1);
-var rule75 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_unicorn2.default, "throw-new-error", "eslint-plugin-unicorn"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/throw-new-error");
-var deprecatedRule21 = withDeprecatedRuleLifecycle(rule75, {
+var rule78 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_unicorn2.default, "throw-new-error", "eslint-plugin-unicorn"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/throw-new-error");
+var deprecatedRule21 = withDeprecatedRuleLifecycle(rule78, {
   message: "Deprecated in favor of unicorn/throw-new-error.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -4791,7 +5338,7 @@ var throw_new_error_default = deprecatedRule21;
 // dist/rules/typescript-array-callback-return-type.js
 var import_type_utils7 = require("@typescript-eslint/type-utils");
 var import_utils10 = require("@typescript-eslint/utils");
-var import_ts_extras48 = require("ts-extras");
+var import_ts_extras51 = require("ts-extras");
 var arrayCallbackMethodNames = /* @__PURE__ */ new Set([
   "every",
   "find",
@@ -4809,8 +5356,8 @@ var isArrayLikeType2 = (typeChecker, type) => {
   const apparentType = typeChecker.getApparentType(type);
   return typeChecker.isArrayType(apparentType) || typeChecker.isTupleType(apparentType) || (0, import_type_utils7.isTypeArrayTypeOrUnionOfArrayTypes)(type, typeChecker) || (0, import_type_utils7.containsAllTypesByName)(type, false, readonlyArrayTypeNames2, true);
 };
-var isFirstCallbackArgument = (callExpression, callback) => (0, import_ts_extras48.arrayFirst)(callExpression.arguments) === callback;
-var rule76 = ruleCreator({
+var isFirstCallbackArgument = (callExpression, callback) => (0, import_ts_extras51.arrayFirst)(callExpression.arguments) === callback;
+var rule79 = ruleCreator({
   create: (context) => {
     const parserServices = import_utils10.ESLintUtils.getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
@@ -4824,7 +5371,7 @@ var rule76 = ruleCreator({
           return;
         }
         const { callee } = parentNode;
-        if (callee.type !== "MemberExpression" || callee.object.type === "Super" || callee.property.type !== "Identifier" || !(0, import_ts_extras48.setHas)(arrayCallbackMethodNames, callee.property.name)) {
+        if (callee.type !== "MemberExpression" || callee.object.type === "Super" || callee.property.type !== "Identifier" || !(0, import_ts_extras51.setHas)(arrayCallbackMethodNames, callee.property.name)) {
           return;
         }
         const objectType = (0, import_type_utils7.getConstrainedTypeAtLocation)(parserServices, callee.object);
@@ -4857,11 +5404,11 @@ var rule76 = ruleCreator({
   },
   name: "typescript/array-callback-return-type"
 });
-var typescript_array_callback_return_type_default = rule76;
+var typescript_array_callback_return_type_default = rule79;
 
 // dist/rules/typescript-class-methods-use-this.js
-var import_ts_extras49 = require("ts-extras");
-var isNode = (value) => typeof value === "object" && value !== null && (0, import_ts_extras49.objectHasOwn)(value, "type");
+var import_ts_extras52 = require("ts-extras");
+var isNode = (value) => typeof value === "object" && value !== null && (0, import_ts_extras52.objectHasOwn)(value, "type");
 var collectNodeChildren = (node) => {
   let children = [];
   const addNode = (value) => {
@@ -4869,7 +5416,7 @@ var collectNodeChildren = (node) => {
       children = [...children, value];
     }
   };
-  for (const [key, child] of (0, import_ts_extras49.objectEntries)(node)) {
+  for (const [key, child] of (0, import_ts_extras52.objectEntries)(node)) {
     if (key === "loc" || key === "parent" || key === "range") {
       continue;
     }
@@ -4886,7 +5433,7 @@ var collectNodeChildren = (node) => {
 var containsThisExpression = (root) => {
   let stack = [root];
   while (stack.length > 0) {
-    const node = (0, import_ts_extras49.arrayAt)(stack, -1);
+    const node = (0, import_ts_extras52.arrayAt)(stack, -1);
     stack = stack.slice(0, -1);
     if (node === void 0) {
       continue;
@@ -4904,7 +5451,7 @@ var hasThisParameter = (node) => {
 };
 var usesThisExpression = (node) => node.value.body === null ? false : containsThisExpression(node.value.body);
 var shouldSkipMethod = (node) => node.kind !== "method" || node.static || node.value.body === null || hasThisParameter(node) || usesThisExpression(node);
-var rule77 = ruleCreator({
+var rule80 = ruleCreator({
   create: (context) => ({
     MethodDefinition: (node) => {
       if (shouldSkipMethod(node)) {
@@ -4934,7 +5481,7 @@ var rule77 = ruleCreator({
   },
   name: "typescript/class-methods-use-this"
 });
-var deprecatedRule22 = withDeprecatedRuleLifecycle(rule77, {
+var deprecatedRule22 = withDeprecatedRuleLifecycle(rule80, {
   message: "Deprecated in favor of @typescript-eslint/class-methods-use-this.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -4954,7 +5501,7 @@ var typescript_class_methods_use_this_default = deprecatedRule22;
 
 // dist/rules/typescript-consistent-array-type-name.js
 var selector5 = String.raw`:matches(TSTypeAliasDeclaration[typeAnnotation.type='TSArrayType'], TSTypeAliasDeclaration[typeAnnotation.type='TSTupleType'], TSTypeAliasDeclaration[typeAnnotation.type='TSTypeReference']:has(TSTypeReference > Identifier[name='Array'])) > Identifier.id:not([name=/^(?:[A-Z][a-z\d]*)+(?:Array|s)$/u])`;
-var rule78 = ruleCreator({
+var rule81 = ruleCreator({
   create: (context) => ({
     [selector5]: (node) => {
       context.report({
@@ -4981,11 +5528,11 @@ var rule78 = ruleCreator({
   },
   name: "typescript/consistent-array-type-name"
 });
-var typescript_consistent_array_type_name_default = rule78;
+var typescript_consistent_array_type_name_default = rule81;
 
 // dist/rules/typescript-define-function-in-one-statement.js
 var selector6 = "AssignmentExpression > MemberExpression.left > Identifier.object";
-var rule79 = ruleCreator({
+var rule82 = ruleCreator({
   create: (context) => ({
     [selector6]: (node) => {
       context.report({
@@ -5012,11 +5559,11 @@ var rule79 = ruleCreator({
   },
   name: "typescript/define-function-in-one-statement"
 });
-var typescript_define_function_in_one_statement_default = rule79;
+var typescript_define_function_in_one_statement_default = rule82;
 
 // dist/rules/typescript-exhaustive-switch.js
 var selector7 = "SwitchStatement[cases.length>1]:not(:has(SwitchCase[test=null]))";
-var rule80 = ruleCreator({
+var rule83 = ruleCreator({
   create: (context) => ({
     [selector7]: (node) => {
       context.report({
@@ -5043,7 +5590,7 @@ var rule80 = ruleCreator({
   },
   name: "typescript/exhaustive-switch"
 });
-var deprecatedRule23 = withDeprecatedRuleLifecycle(rule80, {
+var deprecatedRule23 = withDeprecatedRuleLifecycle(rule83, {
   message: "Deprecated in favor of @typescript-eslint/switch-exhaustiveness-check.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -5062,12 +5609,12 @@ var deprecatedRule23 = withDeprecatedRuleLifecycle(rule80, {
 var typescript_exhaustive_switch_default = deprecatedRule23;
 
 // dist/rules/typescript-no-boolean-literal-type.js
-var import_ts_extras50 = require("ts-extras");
-var selector8 = (0, import_ts_extras50.arrayJoin)([
+var import_ts_extras53 = require("ts-extras");
+var selector8 = (0, import_ts_extras53.arrayJoin)([
   "TSPropertySignature[optional=true] > TSTypeAnnotation > TSLiteralType > Literal[value=true]",
   "TSPropertySignature[optional=true] > TSTypeAnnotation > TSLiteralType > Literal[value=false]"
 ], ", ");
-var rule81 = ruleCreator({
+var rule84 = ruleCreator({
   create: (context) => ({
     [selector8]: (node) => {
       if (node.type !== "Literal") {
@@ -5099,11 +5646,11 @@ var rule81 = ruleCreator({
   },
   name: "typescript/no-boolean-literal-type"
 });
-var typescript_no_boolean_literal_type_default = rule81;
+var typescript_no_boolean_literal_type_default = rule84;
 
 // dist/rules/typescript-no-complex-declarator-type.js
 var selector9 = "VariableDeclarator:not([id.typeAnnotation], [init.expression.properties.length=0]) > Identifier.id";
-var rule82 = ruleCreator({
+var rule85 = ruleCreator({
   create: (context) => ({
     [selector9]: (node) => {
       context.report({
@@ -5130,11 +5677,11 @@ var rule82 = ruleCreator({
   },
   name: "typescript/no-complex-declarator-type"
 });
-var typescript_no_complex_declarator_type_default = rule82;
+var typescript_no_complex_declarator_type_default = rule85;
 
 // dist/rules/typescript-no-complex-return-type.js
 var selector10 = "ArrowFunctionExpression[returnType=undefined] > :matches(TSAsExpression, TSTypeAssertion) > :matches(FunctionExpression, ArrowFunctionExpression, ObjectExpression, ClassExpression)";
-var rule83 = ruleCreator({
+var rule86 = ruleCreator({
   create: (context) => ({
     [selector10]: (node) => {
       context.report({
@@ -5161,11 +5708,11 @@ var rule83 = ruleCreator({
   },
   name: "typescript/no-complex-return-type"
 });
-var typescript_no_complex_return_type_default = rule83;
+var typescript_no_complex_return_type_default = rule86;
 
 // dist/rules/typescript-no-empty-interfaces.js
 var selector11 = "TSInterfaceDeclaration[body.body.length=0][extends.length=0] > Identifier.id";
-var rule84 = ruleCreator({
+var rule87 = ruleCreator({
   create: (context) => ({
     [selector11]: (node) => {
       context.report({
@@ -5192,7 +5739,7 @@ var rule84 = ruleCreator({
   },
   name: "typescript/no-empty-interfaces"
 });
-var deprecatedRule24 = withDeprecatedRuleLifecycle(rule84, {
+var deprecatedRule24 = withDeprecatedRuleLifecycle(rule87, {
   message: "Deprecated in favor of @typescript-eslint/no-empty-object-type.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -5211,12 +5758,12 @@ var deprecatedRule24 = withDeprecatedRuleLifecycle(rule84, {
 var typescript_no_empty_interfaces_default = deprecatedRule24;
 
 // dist/rules/typescript-no-inferrable-types.js
-var import_ts_extras51 = require("ts-extras");
-var selector12 = (0, import_ts_extras51.arrayJoin)([
+var import_ts_extras54 = require("ts-extras");
+var selector12 = (0, import_ts_extras54.arrayJoin)([
   "PropertyDefinition[value.type='Literal'] > TSTypeAnnotation",
   "VariableDeclarator[init.type='Literal'] > Identifier.id > TSTypeAnnotation"
 ], ", ");
-var rule85 = ruleCreator({
+var rule88 = ruleCreator({
   create: (context) => ({
     [selector12]: (node) => {
       context.report({
@@ -5243,7 +5790,7 @@ var rule85 = ruleCreator({
   },
   name: "typescript/no-inferrable-types"
 });
-var deprecatedRule25 = withDeprecatedRuleLifecycle(rule85, {
+var deprecatedRule25 = withDeprecatedRuleLifecycle(rule88, {
   message: "Deprecated in favor of @typescript-eslint/no-inferrable-types.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -5263,7 +5810,7 @@ var typescript_no_inferrable_types_default = deprecatedRule25;
 
 // dist/rules/typescript-no-multi-type-tuples.js
 var selector13 = "TSTupleType > TSUnionType:not([types.length=1])";
-var rule86 = ruleCreator({
+var rule89 = ruleCreator({
   create: (context) => ({
     [selector13]: (node) => {
       context.report({
@@ -5290,13 +5837,13 @@ var rule86 = ruleCreator({
   },
   name: "typescript/no-multi-type-tuples"
 });
-var typescript_no_multi_type_tuples_default = rule86;
+var typescript_no_multi_type_tuples_default = rule89;
 
 // dist/rules/typescript-no-never.js
 var import_type_utils8 = require("@typescript-eslint/type-utils");
 var import_utils11 = require("@typescript-eslint/utils");
 var isTypeAliasNeverIdentifier = (node) => node.parent.type === "TSTypeAliasDeclaration" && node.parent.id === node && node.parent.typeAnnotation.type === "TSNeverKeyword";
-var rule87 = ruleCreator({
+var rule90 = ruleCreator({
   create: (context) => {
     const parserServices = import_utils11.ESLintUtils.getParserServices(context);
     return {
@@ -5334,10 +5881,10 @@ var rule87 = ruleCreator({
   },
   name: "typescript/no-never"
 });
-var typescript_no_never_default = rule87;
+var typescript_no_never_default = rule90;
 
 // dist/rules/typescript-no-redundant-undefined-const.js
-var import_ts_extras52 = require("ts-extras");
+var import_ts_extras55 = require("ts-extras");
 var buildFixedTypeText = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
@@ -5349,10 +5896,10 @@ var buildFixedTypeText = (sourceCode, unionType) => {
       sourceCode.getText(typeNode)
     ];
   }
-  if ((0, import_ts_extras52.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
+  if ((0, import_ts_extras55.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
     return void 0;
   }
-  return (0, import_ts_extras52.arrayJoin)(nonUndefinedTypeTexts, " | ");
+  return (0, import_ts_extras55.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
 var getTypeAnnotationFromDeclarator = (declarator) => {
   if (declarator.id.type === "Identifier" || declarator.id.type === "ArrayPattern" || declarator.id.type === "ObjectPattern") {
@@ -5360,14 +5907,14 @@ var getTypeAnnotationFromDeclarator = (declarator) => {
   }
   return void 0;
 };
-var unwrapExpression = (expression) => {
+var unwrapExpression2 = (expression) => {
   if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
-    return unwrapExpression(expression.expression);
+    return unwrapExpression2(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression = (expression) => {
-  const unwrappedExpression = unwrapExpression(expression);
+  const unwrappedExpression = unwrapExpression2(expression);
   if (unwrappedExpression.type === "ArrayExpression") {
     return true;
   }
@@ -5394,7 +5941,7 @@ var isDefinitelyDefinedExpression = (expression) => {
   }
   return false;
 };
-var rule88 = ruleCreator({
+var rule91 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -5416,7 +5963,7 @@ var rule88 = ruleCreator({
           return;
         }
         const fixedTypeText = buildFixedTypeText(sourceCode, typeAnnotation.typeAnnotation);
-        if (!(0, import_ts_extras52.isDefined)(fixedTypeText)) {
+        if (!(0, import_ts_extras55.isDefined)(fixedTypeText)) {
           return;
         }
         const fix = (fixer) => fixer.replaceText(typeAnnotation.typeAnnotation, fixedTypeText);
@@ -5454,10 +6001,10 @@ var rule88 = ruleCreator({
   },
   name: "typescript/no-redundant-undefined-const"
 });
-var typescript_no_redundant_undefined_const_default = rule88;
+var typescript_no_redundant_undefined_const_default = rule91;
 
 // dist/rules/typescript-no-redundant-undefined-default-parameter.js
-var import_ts_extras53 = require("ts-extras");
+var import_ts_extras56 = require("ts-extras");
 var functionLikeNodeSelector = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
 var getParametersFromFunctionLikeNode = (node) => {
   if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "TSCallSignatureDeclaration" || node.type === "TSConstructSignatureDeclaration" || node.type === "TSConstructorType" || node.type === "TSDeclareFunction" || node.type === "TSEmptyBodyFunctionExpression" || node.type === "TSFunctionType" || node.type === "TSMethodSignature") {
@@ -5486,14 +6033,14 @@ var getTypeAnnotationFromAssignmentPattern = (assignmentPattern) => {
   }
   return assignmentPattern.left.typeAnnotation;
 };
-var unwrapExpression2 = (expression) => {
+var unwrapExpression3 = (expression) => {
   if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
-    return unwrapExpression2(expression.expression);
+    return unwrapExpression3(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression2 = (expression) => {
-  const unwrappedExpression = unwrapExpression2(expression);
+  const unwrappedExpression = unwrapExpression3(expression);
   if (unwrappedExpression.type === "ArrayExpression") {
     return true;
   }
@@ -5531,12 +6078,12 @@ var buildFixedTypeText2 = (sourceCode, unionType) => {
       sourceCode.getText(typeNode)
     ];
   }
-  if ((0, import_ts_extras53.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
+  if ((0, import_ts_extras56.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
     return void 0;
   }
-  return (0, import_ts_extras53.arrayJoin)(nonUndefinedTypeTexts, " | ");
+  return (0, import_ts_extras56.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
-var rule89 = ruleCreator({
+var rule92 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -5561,7 +6108,7 @@ var rule89 = ruleCreator({
             continue;
           }
           const fixedTypeText = buildFixedTypeText2(sourceCode, typeAnnotation.typeAnnotation);
-          if (!(0, import_ts_extras53.isDefined)(fixedTypeText)) {
+          if (!(0, import_ts_extras56.isDefined)(fixedTypeText)) {
             continue;
           }
           const fix = (fixer) => fixer.replaceText(typeAnnotation.typeAnnotation, fixedTypeText);
@@ -5600,10 +6147,10 @@ var rule89 = ruleCreator({
   },
   name: "typescript/no-redundant-undefined-default-parameter"
 });
-var typescript_no_redundant_undefined_default_parameter_default = rule89;
+var typescript_no_redundant_undefined_default_parameter_default = rule92;
 
 // dist/rules/typescript-no-redundant-undefined-let.js
-var import_ts_extras54 = require("ts-extras");
+var import_ts_extras57 = require("ts-extras");
 var buildFixedTypeText3 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
@@ -5615,19 +6162,19 @@ var buildFixedTypeText3 = (sourceCode, unionType) => {
       sourceCode.getText(typeNode)
     ];
   }
-  if ((0, import_ts_extras54.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
+  if ((0, import_ts_extras57.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
     return void 0;
   }
-  return (0, import_ts_extras54.arrayJoin)(nonUndefinedTypeTexts, " | ");
+  return (0, import_ts_extras57.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
-var unwrapExpression3 = (expression) => {
+var unwrapExpression4 = (expression) => {
   if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
-    return unwrapExpression3(expression.expression);
+    return unwrapExpression4(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression3 = (expression) => {
-  const unwrappedExpression = unwrapExpression3(expression);
+  const unwrappedExpression = unwrapExpression4(expression);
   if (unwrappedExpression.type === "ArrayExpression") {
     return true;
   }
@@ -5661,7 +6208,7 @@ var isNeverReassigned = (sourceCode, declarator) => {
   }
   return !declaredVariable.references.some((reference) => reference.isWrite() && reference.init !== true);
 };
-var rule90 = ruleCreator({
+var rule93 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -5688,7 +6235,7 @@ var rule90 = ruleCreator({
           return;
         }
         const fixedTypeText = buildFixedTypeText3(sourceCode, typeAnnotation.typeAnnotation);
-        if (!(0, import_ts_extras54.isDefined)(fixedTypeText)) {
+        if (!(0, import_ts_extras57.isDefined)(fixedTypeText)) {
           return;
         }
         const fix = (fixer) => fixer.replaceText(typeAnnotation.typeAnnotation, fixedTypeText);
@@ -5726,11 +6273,11 @@ var rule90 = ruleCreator({
   },
   name: "typescript/no-redundant-undefined-let"
 });
-var typescript_no_redundant_undefined_let_default = rule90;
+var typescript_no_redundant_undefined_let_default = rule93;
 
 // dist/rules/typescript-no-redundant-undefined-optional.js
-var import_ts_extras55 = require("ts-extras");
-var selector14 = (0, import_ts_extras55.arrayJoin)([
+var import_ts_extras58 = require("ts-extras");
+var selector14 = (0, import_ts_extras58.arrayJoin)([
   "Identifier[optional=true] > TSTypeAnnotation > TSUnionType",
   "TSNamedTupleMember[optional=true] > TSUnionType",
   "TSOptionalType > TSUnionType"
@@ -5746,12 +6293,12 @@ var buildFixedTypeText4 = (sourceCode, unionType) => {
       sourceCode.getText(typeNode)
     ];
   }
-  if ((0, import_ts_extras55.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
+  if ((0, import_ts_extras58.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
     return void 0;
   }
-  return (0, import_ts_extras55.arrayJoin)(nonUndefinedTypeTexts, " | ");
+  return (0, import_ts_extras58.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
-var rule91 = ruleCreator({
+var rule94 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -5760,7 +6307,7 @@ var rule91 = ruleCreator({
           return;
         }
         const fixedTypeText = buildFixedTypeText4(sourceCode, node);
-        if (!(0, import_ts_extras55.isDefined)(fixedTypeText)) {
+        if (!(0, import_ts_extras58.isDefined)(fixedTypeText)) {
           return;
         }
         const fix = (fixer) => fixer.replaceText(node, fixedTypeText);
@@ -5798,10 +6345,10 @@ var rule91 = ruleCreator({
   },
   name: "typescript/no-redundant-undefined-optional"
 });
-var typescript_no_redundant_undefined_optional_default = rule91;
+var typescript_no_redundant_undefined_optional_default = rule94;
 
 // dist/rules/typescript-no-redundant-undefined-promise-return-type.js
-var import_ts_extras56 = require("ts-extras");
+var import_ts_extras59 = require("ts-extras");
 var buildFixedTypeText5 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
@@ -5813,19 +6360,19 @@ var buildFixedTypeText5 = (sourceCode, unionType) => {
       sourceCode.getText(typeNode)
     ];
   }
-  if ((0, import_ts_extras56.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
+  if ((0, import_ts_extras59.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
     return void 0;
   }
-  return (0, import_ts_extras56.arrayJoin)(nonUndefinedTypeTexts, " | ");
+  return (0, import_ts_extras59.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
-var unwrapExpression4 = (expression) => {
+var unwrapExpression5 = (expression) => {
   if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
-    return unwrapExpression4(expression.expression);
+    return unwrapExpression5(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression4 = (expression) => {
-  const unwrappedExpression = unwrapExpression4(expression);
+  const unwrappedExpression = unwrapExpression5(expression);
   if (unwrappedExpression.type === "ArrayExpression") {
     return true;
   }
@@ -5854,7 +6401,7 @@ var isDefinitelyDefinedExpression4 = (expression) => {
     return true;
   }
   if (unwrappedExpression.type === "SequenceExpression") {
-    const lastExpression = (0, import_ts_extras56.arrayAt)(unwrappedExpression.expressions, -1);
+    const lastExpression = (0, import_ts_extras59.arrayAt)(unwrappedExpression.expressions, -1);
     return lastExpression !== void 0 && isDefinitelyDefinedExpression4(lastExpression);
   }
   if (unwrappedExpression.type === "TemplateLiteral") {
@@ -5870,7 +6417,7 @@ var hasDefinitelyDefinedReturnValue = (node) => {
   if (body.body.length !== 1) {
     return false;
   }
-  const statement = (0, import_ts_extras56.arrayFirst)(body.body);
+  const statement = (0, import_ts_extras59.arrayFirst)(body.body);
   if (statement === void 0) {
     return false;
   }
@@ -5906,7 +6453,7 @@ var getPromiseValueUnionType = (returnType) => {
   }
   return promiseValueType;
 };
-var rule92 = ruleCreator({
+var rule95 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -5926,7 +6473,7 @@ var rule92 = ruleCreator({
           return;
         }
         const fixedPromiseValueTypeText = buildFixedTypeText5(sourceCode, promiseValueUnionType);
-        if (!(0, import_ts_extras56.isDefined)(fixedPromiseValueTypeText)) {
+        if (!(0, import_ts_extras59.isDefined)(fixedPromiseValueTypeText)) {
           return;
         }
         const fix = (fixer) => fixer.replaceText(promiseValueUnionType, fixedPromiseValueTypeText);
@@ -5964,10 +6511,10 @@ var rule92 = ruleCreator({
   },
   name: "typescript/no-redundant-undefined-promise-return-type"
 });
-var typescript_no_redundant_undefined_promise_return_type_default = rule92;
+var typescript_no_redundant_undefined_promise_return_type_default = rule95;
 
 // dist/rules/typescript-no-redundant-undefined-readonly-property.js
-var import_ts_extras57 = require("ts-extras");
+var import_ts_extras60 = require("ts-extras");
 var buildFixedTypeText6 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
@@ -5979,19 +6526,19 @@ var buildFixedTypeText6 = (sourceCode, unionType) => {
       sourceCode.getText(typeNode)
     ];
   }
-  if ((0, import_ts_extras57.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
+  if ((0, import_ts_extras60.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
     return void 0;
   }
-  return (0, import_ts_extras57.arrayJoin)(nonUndefinedTypeTexts, " | ");
+  return (0, import_ts_extras60.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
-var unwrapExpression5 = (expression) => {
+var unwrapExpression6 = (expression) => {
   if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
-    return unwrapExpression5(expression.expression);
+    return unwrapExpression6(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression5 = (expression) => {
-  const unwrappedExpression = unwrapExpression5(expression);
+  const unwrappedExpression = unwrapExpression6(expression);
   if (unwrappedExpression.type === "ArrayExpression") {
     return true;
   }
@@ -6018,7 +6565,7 @@ var isDefinitelyDefinedExpression5 = (expression) => {
   }
   return false;
 };
-var rule93 = ruleCreator({
+var rule96 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -6043,7 +6590,7 @@ var rule93 = ruleCreator({
           return;
         }
         const fixedTypeText = buildFixedTypeText6(sourceCode, typeAnnotation.typeAnnotation);
-        if (!(0, import_ts_extras57.isDefined)(fixedTypeText)) {
+        if (!(0, import_ts_extras60.isDefined)(fixedTypeText)) {
           return;
         }
         const fix = (fixer) => fixer.replaceText(typeAnnotation.typeAnnotation, fixedTypeText);
@@ -6081,10 +6628,10 @@ var rule93 = ruleCreator({
   },
   name: "typescript/no-redundant-undefined-readonly-property"
 });
-var typescript_no_redundant_undefined_readonly_property_default = rule93;
+var typescript_no_redundant_undefined_readonly_property_default = rule96;
 
 // dist/rules/typescript-no-redundant-undefined-return-type.js
-var import_ts_extras58 = require("ts-extras");
+var import_ts_extras61 = require("ts-extras");
 var buildFixedTypeText7 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
@@ -6096,19 +6643,19 @@ var buildFixedTypeText7 = (sourceCode, unionType) => {
       sourceCode.getText(typeNode)
     ];
   }
-  if ((0, import_ts_extras58.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
+  if ((0, import_ts_extras61.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
     return void 0;
   }
-  return (0, import_ts_extras58.arrayJoin)(nonUndefinedTypeTexts, " | ");
+  return (0, import_ts_extras61.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
-var unwrapExpression6 = (expression) => {
+var unwrapExpression7 = (expression) => {
   if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
-    return unwrapExpression6(expression.expression);
+    return unwrapExpression7(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression6 = (expression) => {
-  const unwrappedExpression = unwrapExpression6(expression);
+  const unwrappedExpression = unwrapExpression7(expression);
   if (unwrappedExpression.type === "ArrayExpression") {
     return true;
   }
@@ -6137,7 +6684,7 @@ var isDefinitelyDefinedExpression6 = (expression) => {
     return true;
   }
   if (unwrappedExpression.type === "SequenceExpression") {
-    const lastExpression = (0, import_ts_extras58.arrayAt)(unwrappedExpression.expressions, -1);
+    const lastExpression = (0, import_ts_extras61.arrayAt)(unwrappedExpression.expressions, -1);
     return lastExpression !== void 0 && isDefinitelyDefinedExpression6(lastExpression);
   }
   if (unwrappedExpression.type === "TemplateLiteral") {
@@ -6153,7 +6700,7 @@ var hasDefinitelyDefinedReturnValue2 = (node) => {
   if (body.body.length !== 1) {
     return false;
   }
-  const statement = (0, import_ts_extras58.arrayFirst)(body.body);
+  const statement = (0, import_ts_extras61.arrayFirst)(body.body);
   if (statement === void 0) {
     return false;
   }
@@ -6165,7 +6712,7 @@ var hasDefinitelyDefinedReturnValue2 = (node) => {
   }
   return isDefinitelyDefinedExpression6(statement.argument);
 };
-var rule94 = ruleCreator({
+var rule97 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -6184,7 +6731,7 @@ var rule94 = ruleCreator({
           return;
         }
         const fixedTypeText = buildFixedTypeText7(sourceCode, returnType.typeAnnotation);
-        if (!(0, import_ts_extras58.isDefined)(fixedTypeText)) {
+        if (!(0, import_ts_extras61.isDefined)(fixedTypeText)) {
           return;
         }
         const fix = (fixer) => fixer.replaceText(returnType.typeAnnotation, fixedTypeText);
@@ -6222,10 +6769,10 @@ var rule94 = ruleCreator({
   },
   name: "typescript/no-redundant-undefined-return-type"
 });
-var typescript_no_redundant_undefined_return_type_default = rule94;
+var typescript_no_redundant_undefined_return_type_default = rule97;
 
 // dist/rules/typescript-no-redundant-undefined-var.js
-var import_ts_extras59 = require("ts-extras");
+var import_ts_extras62 = require("ts-extras");
 var buildFixedTypeText8 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
@@ -6237,19 +6784,19 @@ var buildFixedTypeText8 = (sourceCode, unionType) => {
       sourceCode.getText(typeNode)
     ];
   }
-  if ((0, import_ts_extras59.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
+  if ((0, import_ts_extras62.isEmpty)(nonUndefinedTypeTexts) || nonUndefinedTypeTexts.length === unionType.types.length) {
     return void 0;
   }
-  return (0, import_ts_extras59.arrayJoin)(nonUndefinedTypeTexts, " | ");
+  return (0, import_ts_extras62.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
-var unwrapExpression7 = (expression) => {
+var unwrapExpression8 = (expression) => {
   if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
-    return unwrapExpression7(expression.expression);
+    return unwrapExpression8(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression7 = (expression) => {
-  const unwrappedExpression = unwrapExpression7(expression);
+  const unwrappedExpression = unwrapExpression8(expression);
   if (unwrappedExpression.type === "ArrayExpression") {
     return true;
   }
@@ -6283,7 +6830,7 @@ var isNeverReassigned2 = (sourceCode, declarator) => {
   }
   return !declaredVariable.references.some((reference) => reference.isWrite() && reference.init !== true);
 };
-var rule95 = ruleCreator({
+var rule98 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -6310,7 +6857,7 @@ var rule95 = ruleCreator({
           return;
         }
         const fixedTypeText = buildFixedTypeText8(sourceCode, typeAnnotation.typeAnnotation);
-        if (!(0, import_ts_extras59.isDefined)(fixedTypeText)) {
+        if (!(0, import_ts_extras62.isDefined)(fixedTypeText)) {
           return;
         }
         const fix = (fixer) => fixer.replaceText(typeAnnotation.typeAnnotation, fixedTypeText);
@@ -6348,7 +6895,7 @@ var rule95 = ruleCreator({
   },
   name: "typescript/no-redundant-undefined-var"
 });
-var typescript_no_redundant_undefined_var_default = rule95;
+var typescript_no_redundant_undefined_var_default = rule98;
 
 // dist/rules/typescript-no-restricted-syntax.js
 var typescriptNoRestrictedSyntaxRule = {
@@ -6387,7 +6934,7 @@ var typescript_no_restricted_syntax_default = deprecatedRule26;
 var import_type_utils9 = require("@typescript-eslint/type-utils");
 var import_utils12 = require("@typescript-eslint/utils");
 var tsutils4 = __toESM(require("tsutils"), 1);
-var rule96 = ruleCreator({
+var rule99 = ruleCreator({
   create: (context) => {
     const parserServices = import_utils12.ESLintUtils.getParserServices(context);
     const checker = parserServices.program.getTypeChecker();
@@ -6428,10 +6975,10 @@ var rule96 = ruleCreator({
   },
   name: "typescript/no-unsafe-object-assign"
 });
-var typescript_no_unsafe_object_assign_default = rule96;
+var typescript_no_unsafe_object_assign_default = rule99;
 
 // dist/rules/typescript-no-unsafe-object-assignment.js
-var rule97 = {
+var rule100 = {
   ...typescript_no_unsafe_object_assign_default,
   meta: {
     deprecated: false,
@@ -6445,11 +6992,11 @@ var rule97 = {
     }
   }
 };
-var typescript_no_unsafe_object_assignment_default = rule97;
+var typescript_no_unsafe_object_assignment_default = rule100;
 
 // dist/rules/typescript-prefer-array-type-alias.js
 var selector15 = String.raw`TSTypeAliasDeclaration > Identifier.id:matches([parent.typeAnnotation.type='TSArrayType'], [parent.typeAnnotation.type='TSTupleType']):not([name=/^(?:[A-Z][a-z\d]*)+(?:Array|s)$/u])`;
-var rule98 = ruleCreator({
+var rule101 = ruleCreator({
   create: (context) => ({
     [selector15]: (node) => {
       context.report({
@@ -6476,11 +7023,11 @@ var rule98 = ruleCreator({
   },
   name: "typescript/prefer-array-type-alias"
 });
-var typescript_prefer_array_type_alias_default = rule98;
+var typescript_prefer_array_type_alias_default = rule101;
 
 // dist/rules/typescript-prefer-class-method.js
 var selector16 = "PropertyDefinition:not([typeAnnotation]) > ArrowFunctionExpression";
-var rule99 = ruleCreator({
+var rule102 = ruleCreator({
   create: (context) => ({
     [selector16]: (node) => {
       context.report({
@@ -6507,12 +7054,12 @@ var rule99 = ruleCreator({
   },
   name: "typescript/prefer-class-method"
 });
-var typescript_prefer_class_method_default = rule99;
+var typescript_prefer_class_method_default = rule102;
 
 // dist/rules/typescript-prefer-enum.js
 var import_type_utils10 = require("@typescript-eslint/type-utils");
 var import_utils13 = require("@typescript-eslint/utils");
-var import_ts_extras60 = require("ts-extras");
+var import_ts_extras63 = require("ts-extras");
 var tsutils5 = __toESM(require("tsutils"), 1);
 var import_typescript = __toESM(require("typescript"), 1);
 var isEnumLikeOrUndefinedType = (checker, type) => {
@@ -6531,7 +7078,7 @@ var isEnumLikeOrUndefinedType = (checker, type) => {
   return hasEnumLike;
 };
 var isStringLiteral = (node) => node.type === "Literal" && typeof node.value === "string";
-var rule100 = ruleCreator({
+var rule103 = ruleCreator({
   create: (context) => {
     const parserServices = import_utils13.ESLintUtils.getParserServices(context);
     const checker = parserServices.program.getTypeChecker();
@@ -6573,9 +7120,9 @@ var rule100 = ruleCreator({
         if (functionNode === null) {
           return;
         }
-        const signature = (0, import_ts_extras60.arrayFirst)((0, import_type_utils10.getConstrainedTypeAtLocation)(parserServices, functionNode).getCallSignatures());
-        const returnType = (0, import_ts_extras60.isDefined)(signature) ? checker.getReturnTypeOfSignature(signature) : void 0;
-        if (!(0, import_ts_extras60.isDefined)(returnType)) {
+        const signature = (0, import_ts_extras63.arrayFirst)((0, import_type_utils10.getConstrainedTypeAtLocation)(parserServices, functionNode).getCallSignatures());
+        const returnType = (0, import_ts_extras63.isDefined)(signature) ? checker.getReturnTypeOfSignature(signature) : void 0;
+        if (!(0, import_ts_extras63.isDefined)(returnType)) {
           return;
         }
         if (!isEnumLikeOrUndefinedType(checker, returnType)) {
@@ -6626,7 +7173,7 @@ var rule100 = ruleCreator({
   },
   name: "typescript/prefer-enum"
 });
-var typescript_prefer_enum_default = rule100;
+var typescript_prefer_enum_default = rule103;
 
 // dist/rules/typescript-prefer-named-tuple-members.js
 var isUnnamedTupleElement = (tupleElement) => {
@@ -6663,7 +7210,7 @@ var getTupleMemberReplacementText = (tupleElement, memberName2, sourceCode) => {
   }
   return `${memberName2}: ${sourceCode.getText(tupleElement)}`;
 };
-var rule101 = ruleCreator({
+var rule104 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -6729,7 +7276,7 @@ var rule101 = ruleCreator({
   },
   name: "typescript/prefer-named-tuple-members"
 });
-var typescript_prefer_named_tuple_members_default = rule101;
+var typescript_prefer_named_tuple_members_default = rule104;
 
 // dist/rules/typescript-prefer-readonly-array-parameter.js
 var functionLikeNodeSelector2 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
@@ -6783,7 +7330,7 @@ var buildReadonlyArrayLikeFix = (node, sourceCode) => {
   }
   return (fixer) => fixer.replaceText(node, `readonly ${sourceCode.getText(node)}`);
 };
-var rule102 = ruleCreator({
+var rule105 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -6836,15 +7383,15 @@ var rule102 = ruleCreator({
   },
   name: "typescript/prefer-readonly-array-parameter"
 });
-var typescript_prefer_readonly_array_parameter_default = rule102;
+var typescript_prefer_readonly_array_parameter_default = rule105;
 
 // dist/rules/typescript-prefer-readonly-array.js
-var import_ts_extras61 = require("ts-extras");
-var selector17 = (0, import_ts_extras61.arrayJoin)([
+var import_ts_extras64 = require("ts-extras");
+var selector17 = (0, import_ts_extras64.arrayJoin)([
   ":not(TSTypeOperator[operator='readonly']) > :matches(TSArrayType, TSTupleType)",
   "TSTypeReference > Identifier[name='Array']"
 ], ", ");
-var rule103 = ruleCreator({
+var rule106 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -6880,11 +7427,11 @@ var rule103 = ruleCreator({
   },
   name: "typescript/prefer-readonly-array"
 });
-var typescript_prefer_readonly_array_default = rule103;
+var typescript_prefer_readonly_array_default = rule106;
 
 // dist/rules/typescript-prefer-readonly-index-signature.js
 var selector18 = "TSIndexSignature[readonly!=true]";
-var rule104 = ruleCreator({
+var rule107 = ruleCreator({
   create: (context) => ({
     [selector18]: (node) => {
       if (node.type !== "TSIndexSignature" || node.readonly) {
@@ -6916,11 +7463,11 @@ var rule104 = ruleCreator({
   },
   name: "typescript/prefer-readonly-index-signature"
 });
-var typescript_prefer_readonly_index_signature_default = rule104;
+var typescript_prefer_readonly_index_signature_default = rule107;
 
 // dist/rules/typescript-prefer-readonly-map.js
 var selector19 = "TSTypeReference > Identifier[name='Map']";
-var rule105 = ruleCreator({
+var rule108 = ruleCreator({
   create: (context) => ({
     [selector19]: (node) => {
       if (node.type !== "Identifier") {
@@ -6952,12 +7499,12 @@ var rule105 = ruleCreator({
   },
   name: "typescript/prefer-readonly-map"
 });
-var typescript_prefer_readonly_map_default = rule105;
+var typescript_prefer_readonly_map_default = rule108;
 
 // dist/rules/typescript-prefer-readonly-property.js
-var import_ts_extras62 = require("ts-extras");
+var import_ts_extras65 = require("ts-extras");
 var selector20 = ":matches(PropertyDefinition, TSPropertySignature)[readonly!=true]";
-var rule106 = ruleCreator({
+var rule109 = ruleCreator({
   create: (context) => ({
     [selector20]: (node) => {
       if (node.type !== "PropertyDefinition" && node.type !== "TSPropertySignature") {
@@ -6968,7 +7515,7 @@ var rule106 = ruleCreator({
       context.report({
         messageId: "forbidden",
         node,
-        ...(0, import_ts_extras62.isDefined)(fix) ? {
+        ...(0, import_ts_extras65.isDefined)(fix) ? {
           fix,
           suggest: [
             {
@@ -7000,7 +7547,7 @@ var rule106 = ruleCreator({
   },
   name: "typescript/prefer-readonly-property"
 });
-var typescript_prefer_readonly_property_default = rule106;
+var typescript_prefer_readonly_property_default = rule109;
 
 // dist/rules/typescript-prefer-readonly-record.js
 var selector21 = "TSTypeReference > Identifier[name='Record']";
@@ -7012,7 +7559,7 @@ var isReadonlyWrappedRecord = (typeReference) => {
   const maybeReadonlyTypeReference = parent.parent;
   return maybeReadonlyTypeReference?.type === "TSTypeReference" && maybeReadonlyTypeReference.typeName.type === "Identifier" && maybeReadonlyTypeReference.typeName.name === "Readonly";
 };
-var rule107 = ruleCreator({
+var rule110 = ruleCreator({
   create: (context) => ({
     [selector21]: (node) => {
       if (node.type !== "Identifier") {
@@ -7051,11 +7598,11 @@ var rule107 = ruleCreator({
   },
   name: "typescript/prefer-readonly-record"
 });
-var typescript_prefer_readonly_record_default = rule107;
+var typescript_prefer_readonly_record_default = rule110;
 
 // dist/rules/typescript-prefer-readonly-set.js
 var selector22 = "TSTypeReference > Identifier[name='Set']";
-var rule108 = ruleCreator({
+var rule111 = ruleCreator({
   create: (context) => ({
     [selector22]: (node) => {
       if (node.type !== "Identifier") {
@@ -7087,12 +7634,12 @@ var rule108 = ruleCreator({
   },
   name: "typescript/prefer-readonly-set"
 });
-var typescript_prefer_readonly_set_default = rule108;
+var typescript_prefer_readonly_set_default = rule111;
 
 // dist/rules/typescript-require-prop-type-annotation.js
-var import_ts_extras63 = require("ts-extras");
+var import_ts_extras66 = require("ts-extras");
 var selector23 = "PropertyDefinition[typeAnnotation=undefined][value=null]";
-var rule109 = ruleCreator({
+var rule112 = ruleCreator({
   create: (context) => ({
     [selector23]: (node) => {
       if (node.type !== "PropertyDefinition") {
@@ -7103,7 +7650,7 @@ var rule109 = ruleCreator({
       context.report({
         messageId: "forbidden",
         node,
-        ...(0, import_ts_extras63.isDefined)(fix) ? {
+        ...(0, import_ts_extras66.isDefined)(fix) ? {
           fix,
           suggest: [
             {
@@ -7135,7 +7682,7 @@ var rule109 = ruleCreator({
   },
   name: "typescript/require-prop-type-annotation"
 });
-var typescript_require_prop_type_annotation_default = rule109;
+var typescript_require_prop_type_annotation_default = rule112;
 
 // dist/rules/typescript-require-readonly-array-property-type.js
 var isArrayTypeReference2 = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Array";
@@ -7171,7 +7718,7 @@ var isTopLevelPropertySignature = (node) => {
   const maybeTypeAliasDeclaration = parent.parent;
   return maybeTypeAliasDeclaration?.type === "TSTypeAliasDeclaration";
 };
-var rule110 = ruleCreator({
+var rule113 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -7221,7 +7768,7 @@ var rule110 = ruleCreator({
   },
   name: "typescript/require-readonly-array-property-type"
 });
-var typescript_require_readonly_array_property_type_default = rule110;
+var typescript_require_readonly_array_property_type_default = rule113;
 
 // dist/rules/typescript-require-readonly-array-return-type.js
 var functionLikeNodeSelector3 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
@@ -7253,7 +7800,7 @@ var buildReadonlyArrayLikeFix3 = (node, sourceCode) => {
   }
   return (fixer) => fixer.replaceText(node, `readonly ${sourceCode.getText(node)}`);
 };
-var rule111 = ruleCreator({
+var rule114 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -7300,7 +7847,7 @@ var rule111 = ruleCreator({
   },
   name: "typescript/require-readonly-array-return-type"
 });
-var typescript_require_readonly_array_return_type_default = rule111;
+var typescript_require_readonly_array_return_type_default = rule114;
 
 // dist/rules/typescript-require-readonly-array-type-alias.js
 var isArrayTypeReference4 = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Array";
@@ -7325,7 +7872,7 @@ var buildReadonlyArrayLikeFix4 = (node, sourceCode) => {
   }
   return (fixer) => fixer.replaceText(node, `readonly ${sourceCode.getText(node)}`);
 };
-var rule112 = ruleCreator({
+var rule115 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -7368,7 +7915,7 @@ var rule112 = ruleCreator({
   },
   name: "typescript/require-readonly-array-type-alias"
 });
-var typescript_require_readonly_array_type_alias_default = rule112;
+var typescript_require_readonly_array_type_alias_default = rule115;
 
 // dist/rules/typescript-require-readonly-map-parameter-type.js
 var functionLikeNodeSelector4 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
@@ -7411,7 +7958,7 @@ var collectMutableMapTypeNodes = (typeNode) => {
   return [typeNode.typeName];
 };
 var buildReadonlyMapFix = (node) => (fixer) => fixer.replaceText(node, "ReadonlyMap");
-var rule113 = ruleCreator({
+var rule116 = ruleCreator({
   create: (context) => ({
     [functionLikeNodeSelector4]: (node) => {
       const parameters = getParametersFromFunctionLikeNode3(node);
@@ -7461,7 +8008,7 @@ var rule113 = ruleCreator({
   },
   name: "typescript/require-readonly-map-parameter-type"
 });
-var typescript_require_readonly_map_parameter_type_default = rule113;
+var typescript_require_readonly_map_parameter_type_default = rule116;
 
 // dist/rules/typescript-require-readonly-map-property-type.js
 var isMapTypeReference2 = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Map";
@@ -7486,7 +8033,7 @@ var isTopLevelPropertySignature2 = (node) => {
   const maybeTypeAliasDeclaration = parent.parent;
   return maybeTypeAliasDeclaration?.type === "TSTypeAliasDeclaration";
 };
-var rule114 = ruleCreator({
+var rule117 = ruleCreator({
   create: (context) => ({
     "TSPropertySignature[typeAnnotation!=null]": (node) => {
       if (!isTopLevelPropertySignature2(node)) {
@@ -7533,7 +8080,7 @@ var rule114 = ruleCreator({
   },
   name: "typescript/require-readonly-map-property-type"
 });
-var typescript_require_readonly_map_property_type_default = rule114;
+var typescript_require_readonly_map_property_type_default = rule117;
 
 // dist/rules/typescript-require-readonly-map-return-type.js
 var functionLikeNodeSelector5 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
@@ -7554,7 +8101,7 @@ var collectMutableMapTypeNodes3 = (typeNode) => {
   return [typeNode.typeName];
 };
 var buildReadonlyMapFix3 = (node) => (fixer) => fixer.replaceText(node, "ReadonlyMap");
-var rule115 = ruleCreator({
+var rule118 = ruleCreator({
   create: (context) => ({
     [functionLikeNodeSelector5]: (node) => {
       const returnTypeAnnotation = getReturnTypeAnnotationFromFunctionLikeNode2(node);
@@ -7598,7 +8145,7 @@ var rule115 = ruleCreator({
   },
   name: "typescript/require-readonly-map-return-type"
 });
-var typescript_require_readonly_map_return_type_default = rule115;
+var typescript_require_readonly_map_return_type_default = rule118;
 
 // dist/rules/typescript-require-readonly-map-type-alias.js
 var isMapTypeReference4 = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Map";
@@ -7612,7 +8159,7 @@ var collectMutableMapTypeNodes4 = (typeNode) => {
   return [typeNode.typeName];
 };
 var buildReadonlyMapFix4 = (node) => (fixer) => fixer.replaceText(node, "ReadonlyMap");
-var rule116 = ruleCreator({
+var rule119 = ruleCreator({
   create: (context) => ({
     TSTypeAliasDeclaration: (node) => {
       const mutableMapTypeNodes = collectMutableMapTypeNodes4(node.typeAnnotation);
@@ -7652,7 +8199,7 @@ var rule116 = ruleCreator({
   },
   name: "typescript/require-readonly-map-type-alias"
 });
-var typescript_require_readonly_map_type_alias_default = rule116;
+var typescript_require_readonly_map_type_alias_default = rule119;
 
 // dist/rules/typescript-require-readonly-record-parameter-type.js
 var functionLikeNodeSelector6 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
@@ -7706,7 +8253,7 @@ var buildReadonlyRecordFix = (node) => (fixer) => [
   fixer.replaceText(node.typeName, "Readonly<Record"),
   fixer.insertTextAfter(node, ">")
 ];
-var rule117 = ruleCreator({
+var rule120 = ruleCreator({
   create: (context) => ({
     [functionLikeNodeSelector6]: (node) => {
       const parameters = getParametersFromFunctionLikeNode4(node);
@@ -7756,7 +8303,7 @@ var rule117 = ruleCreator({
   },
   name: "typescript/require-readonly-record-parameter-type"
 });
-var typescript_require_readonly_record_parameter_type_default = rule117;
+var typescript_require_readonly_record_parameter_type_default = rule120;
 
 // dist/rules/typescript-require-readonly-record-property-type.js
 var isRecordTypeReference2 = (typeNode) => typeNode.type === "TSTypeReference" && typeNode.typeName.type === "Identifier" && typeNode.typeName.name === "Record";
@@ -7792,7 +8339,7 @@ var isTopLevelPropertySignature3 = (node) => {
   const maybeTypeAliasDeclaration = parent.parent;
   return maybeTypeAliasDeclaration?.type === "TSTypeAliasDeclaration";
 };
-var rule118 = ruleCreator({
+var rule121 = ruleCreator({
   create: (context) => ({
     "TSPropertySignature[typeAnnotation!=null]": (node) => {
       if (!isTopLevelPropertySignature3(node)) {
@@ -7839,7 +8386,7 @@ var rule118 = ruleCreator({
   },
   name: "typescript/require-readonly-record-property-type"
 });
-var typescript_require_readonly_record_property_type_default = rule118;
+var typescript_require_readonly_record_property_type_default = rule121;
 
 // dist/rules/typescript-require-readonly-record-return-type.js
 var functionLikeNodeSelector7 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
@@ -7871,7 +8418,7 @@ var buildReadonlyRecordFix3 = (node) => (fixer) => [
   fixer.replaceText(node.typeName, "Readonly<Record"),
   fixer.insertTextAfter(node, ">")
 ];
-var rule119 = ruleCreator({
+var rule122 = ruleCreator({
   create: (context) => ({
     [functionLikeNodeSelector7]: (node) => {
       const returnTypeAnnotation = getReturnTypeAnnotationFromFunctionLikeNode3(node);
@@ -7915,7 +8462,7 @@ var rule119 = ruleCreator({
   },
   name: "typescript/require-readonly-record-return-type"
 });
-var typescript_require_readonly_record_return_type_default = rule119;
+var typescript_require_readonly_record_return_type_default = rule122;
 
 // dist/rules/typescript-require-readonly-record-type-alias.js
 var isRecordTypeReference4 = (typeNode) => typeNode.type === "TSTypeReference" && typeNode.typeName.type === "Identifier" && typeNode.typeName.name === "Record";
@@ -7940,7 +8487,7 @@ var buildReadonlyRecordFix4 = (node) => (fixer) => [
   fixer.replaceText(node.typeName, "Readonly<Record"),
   fixer.insertTextAfter(node, ">")
 ];
-var rule120 = ruleCreator({
+var rule123 = ruleCreator({
   create: (context) => ({
     TSTypeAliasDeclaration: (node) => {
       const mutableRecordTypeNodes = collectMutableRecordTypeNodes4(node.typeAnnotation);
@@ -7980,7 +8527,7 @@ var rule120 = ruleCreator({
   },
   name: "typescript/require-readonly-record-type-alias"
 });
-var typescript_require_readonly_record_type_alias_default = rule120;
+var typescript_require_readonly_record_type_alias_default = rule123;
 
 // dist/rules/typescript-require-readonly-set-parameter-type.js
 var functionLikeNodeSelector8 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
@@ -8023,7 +8570,7 @@ var collectMutableSetTypeNodes = (typeNode) => {
   return [typeNode.typeName];
 };
 var buildReadonlySetFix = (node) => (fixer) => fixer.replaceText(node, "ReadonlySet");
-var rule121 = ruleCreator({
+var rule124 = ruleCreator({
   create: (context) => ({
     [functionLikeNodeSelector8]: (node) => {
       const parameters = getParametersFromFunctionLikeNode5(node);
@@ -8073,7 +8620,7 @@ var rule121 = ruleCreator({
   },
   name: "typescript/require-readonly-set-parameter-type"
 });
-var typescript_require_readonly_set_parameter_type_default = rule121;
+var typescript_require_readonly_set_parameter_type_default = rule124;
 
 // dist/rules/typescript-require-readonly-set-property-type.js
 var isSetTypeReference2 = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Set";
@@ -8098,7 +8645,7 @@ var isTopLevelPropertySignature4 = (node) => {
   const maybeTypeAliasDeclaration = parent.parent;
   return maybeTypeAliasDeclaration?.type === "TSTypeAliasDeclaration";
 };
-var rule122 = ruleCreator({
+var rule125 = ruleCreator({
   create: (context) => ({
     "TSPropertySignature[typeAnnotation!=null]": (node) => {
       if (!isTopLevelPropertySignature4(node)) {
@@ -8145,7 +8692,7 @@ var rule122 = ruleCreator({
   },
   name: "typescript/require-readonly-set-property-type"
 });
-var typescript_require_readonly_set_property_type_default = rule122;
+var typescript_require_readonly_set_property_type_default = rule125;
 
 // dist/rules/typescript-require-readonly-set-return-type.js
 var functionLikeNodeSelector9 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
@@ -8166,7 +8713,7 @@ var collectMutableSetTypeNodes3 = (typeNode) => {
   return [typeNode.typeName];
 };
 var buildReadonlySetFix3 = (node) => (fixer) => fixer.replaceText(node, "ReadonlySet");
-var rule123 = ruleCreator({
+var rule126 = ruleCreator({
   create: (context) => ({
     [functionLikeNodeSelector9]: (node) => {
       const returnTypeAnnotation = getReturnTypeAnnotationFromFunctionLikeNode4(node);
@@ -8210,7 +8757,7 @@ var rule123 = ruleCreator({
   },
   name: "typescript/require-readonly-set-return-type"
 });
-var typescript_require_readonly_set_return_type_default = rule123;
+var typescript_require_readonly_set_return_type_default = rule126;
 
 // dist/rules/typescript-require-readonly-set-type-alias.js
 var isSetTypeReference4 = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Set";
@@ -8224,7 +8771,7 @@ var collectMutableSetTypeNodes4 = (typeNode) => {
   return [typeNode.typeName];
 };
 var buildReadonlySetFix4 = (node) => (fixer) => fixer.replaceText(node, "ReadonlySet");
-var rule124 = ruleCreator({
+var rule127 = ruleCreator({
   create: (context) => ({
     TSTypeAliasDeclaration: (node) => {
       const mutableSetTypeNodes = collectMutableSetTypeNodes4(node.typeAnnotation);
@@ -8264,13 +8811,13 @@ var rule124 = ruleCreator({
   },
   name: "typescript/require-readonly-set-type-alias"
 });
-var typescript_require_readonly_set_type_alias_default = rule124;
+var typescript_require_readonly_set_type_alias_default = rule127;
 
 // dist/rules/typescript-require-this-void.js
-var import_ts_extras64 = require("ts-extras");
+var import_ts_extras67 = require("ts-extras");
 var selector24 = "MethodDefinition[static=true] > FunctionExpression:not([params.0.name='this'][params.0.typeAnnotation.typeAnnotation.type='TSVoidKeyword'])";
 var createThisVoidSuggestionFix = (sourceCode, functionExpression) => {
-  const firstParameter = (0, import_ts_extras64.arrayFirst)(functionExpression.params);
+  const firstParameter = (0, import_ts_extras67.arrayFirst)(functionExpression.params);
   if (firstParameter?.type === "Identifier" && firstParameter.name === "this") {
     const existingTypeAnnotation = firstParameter.typeAnnotation;
     if (existingTypeAnnotation === void 0) {
@@ -8284,7 +8831,7 @@ var createThisVoidSuggestionFix = (sourceCode, functionExpression) => {
   }
   return (fixer) => fixer.insertTextAfter(openingParenthesisToken, firstParameter === void 0 ? "this: void" : "this: void, ");
 };
-var rule125 = ruleCreator({
+var rule128 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
     return {
@@ -8329,13 +8876,13 @@ var rule125 = ruleCreator({
   },
   name: "typescript/require-this-void"
 });
-var typescript_require_this_void_default = rule125;
+var typescript_require_this_void_default = rule128;
 
 // dist/rules/underscore-internal.js
 var internalTagPattern = /@internal\b/u;
 var isNonUnderscoreIdentifier = (identifier) => !identifier.name.startsWith("_");
 var isExportDeclaration = (node) => node?.type === "ExportDefaultDeclaration" || node?.type === "ExportNamedDeclaration";
-var rule126 = ruleCreator({
+var rule129 = ruleCreator({
   create: (context) => {
     const hasInternalTag = (node) => {
       let commentTargets = [node];
@@ -8438,12 +8985,12 @@ var rule126 = ruleCreator({
   },
   name: "underscore-internal"
 });
-var underscore_internal_default = rule126;
+var underscore_internal_default = rule129;
 
 // dist/rules/unused-internal-properties.js
 var import_eslint_plugin_unicorn3 = __toESM(require("eslint-plugin-unicorn"), 1);
-var rule127 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_unicorn3.default, "no-unused-properties", "eslint-plugin-unicorn"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/unused-internal-properties");
-var deprecatedRule27 = withDeprecatedRuleLifecycle(rule127, {
+var rule130 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_unicorn3.default, "no-unused-properties", "eslint-plugin-unicorn"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/unused-internal-properties");
+var deprecatedRule27 = withDeprecatedRuleLifecycle(rule130, {
   message: "Deprecated in favor of unicorn/no-unused-properties.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -8463,8 +9010,8 @@ var unused_internal_properties_default = deprecatedRule27;
 
 // dist/rules/uppercase-iife.js
 var import_eslint_plugin_unicorn4 = __toESM(require("eslint-plugin-unicorn"), 1);
-var rule128 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_unicorn4.default, "no-unreadable-iife", "eslint-plugin-unicorn"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/uppercase-iife");
-var deprecatedRule28 = withDeprecatedRuleLifecycle(rule128, {
+var rule131 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_unicorn4.default, "no-unreadable-iife", "eslint-plugin-unicorn"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/uppercase-iife");
+var deprecatedRule28 = withDeprecatedRuleLifecycle(rule131, {
   message: "Deprecated in favor of unicorn/no-unreadable-iife.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -8484,8 +9031,8 @@ var uppercase_iife_default = deprecatedRule28;
 
 // dist/rules/words.js
 var import_eslint_plugin_write_good_comments_2 = __toESM(require("eslint-plugin-write-good-comments-2"), 1);
-var rule129 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_write_good_comments_2.default, "write-good-comments", "eslint-plugin-write-good-comments-2"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/words");
-var deprecatedRule29 = withDeprecatedRuleLifecycle(rule129, {
+var rule132 = adaptExternalRule(getExternalRuleFromPlugin(import_eslint_plugin_write_good_comments_2.default, "write-good-comments", "eslint-plugin-write-good-comments-2"), "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/words");
+var deprecatedRule29 = withDeprecatedRuleLifecycle(rule132, {
   message: "Deprecated in favor of write-good-comments/write-good-comments.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -8521,6 +9068,7 @@ var recommendedRuleNames = /* @__PURE__ */ new Set([
   "consistent-optional-props",
   "no-assign-mutated-array",
   "no-const-enum",
+  "no-function-declare-after-return",
   "no-implicit-any-catch",
   "no-internal",
   "no-t",
@@ -8528,6 +9076,7 @@ var recommendedRuleNames = /* @__PURE__ */ new Set([
   "no-unnecessary-break",
   "no-unnecessary-initialization",
   "no-unnecessary-template-literal",
+  "no-vulnerable",
   "throw-error",
   "typescript/no-boolean-literal-type",
   "typescript/prefer-readonly-array",
@@ -8566,6 +9115,7 @@ var baseRules = {
   "no-enum": no_enum_default,
   "no-expression-empty-lines": no_expression_empty_lines_default,
   "no-foreach": no_foreach_default,
+  "no-function-declare-after-return": no_function_declare_after_return_default,
   "no-implicit-any-catch": no_implicit_any_catch_default,
   "no-index-import": no_index_import_default,
   "no-internal": no_internal_default,
@@ -8590,8 +9140,10 @@ var baseRules = {
   "no-unnecessary-initialization": no_unnecessary_initialization_default,
   "no-unnecessary-template-literal": no_unnecessary_template_literal_default,
   "no-unused-disable": no_unused_disable_default,
+  "no-use-extend-native": no_use_extend_native_default,
   "no-useless-generics": no_useless_generics_default,
   "no-value-tostring": no_value_tostring_default,
+  "no-vulnerable": no_vulnerable_default,
   "no-writeonly": no_writeonly_default,
   "object-format": object_format_default,
   "only-export-name": only_export_name_default,
@@ -8672,7 +9224,7 @@ var baseRules = {
   "uppercase-iife": uppercase_iife_default,
   words: words_default
 };
-var ruleCatalog = buildRuleCatalog((0, import_ts_extras65.objectKeys)(baseRules));
+var ruleCatalog = buildRuleCatalog((0, import_ts_extras68.objectKeys)(baseRules));
 var ruleCatalogEntries = ruleCatalog.ordered;
 var ruleCatalogByRuleName = ruleCatalog.byRuleName;
 var ruleCatalogByDocId = ruleCatalog.byDocId;
@@ -8681,8 +9233,8 @@ var withCatalogDocsMetadata = (ruleName, ruleModule) => {
   if (!catalogEntry) {
     throw new Error(`Missing rule catalog entry for rule "${ruleName}".`);
   }
-  const currentDocsMetadata = (0, import_ts_extras65.safeCastTo)(ruleModule.meta.docs ?? {});
-  const hasRequiredTypeChecking = (0, import_ts_extras65.setHas)(rulesWithRequiredTypeChecking, ruleName);
+  const currentDocsMetadata = (0, import_ts_extras68.safeCastTo)(ruleModule.meta.docs ?? {});
+  const hasRequiredTypeChecking = (0, import_ts_extras68.setHas)(rulesWithRequiredTypeChecking, ruleName);
   const deprecatedMetadata = ruleModule.meta.deprecated ?? false;
   const isDeprecatedRule = deprecatedMetadata !== false;
   const docsWithCatalogMetadata = {
@@ -8691,7 +9243,7 @@ var withCatalogDocsMetadata = (ruleName, ruleModule) => {
     catalogIndex: catalogEntry.catalogIndex,
     deprecated: currentDocsMetadata.deprecated ?? isDeprecatedRule,
     frozen: currentDocsMetadata.frozen ?? currentDocsMetadata.deprecated ?? isDeprecatedRule,
-    recommended: (0, import_ts_extras65.setHas)(recommendedRuleNames, ruleName),
+    recommended: (0, import_ts_extras68.setHas)(recommendedRuleNames, ruleName),
     requiresTypeChecking: currentDocsMetadata.requiresTypeChecking ?? hasRequiredTypeChecking,
     ruleName
   };
@@ -8704,7 +9256,7 @@ var withCatalogDocsMetadata = (ruleName, ruleModule) => {
     }
   };
 };
-var decoratedRuleEntries = (0, import_ts_extras65.objectEntries)(baseRules).map(([ruleName, ruleModule]) => [ruleName, withCatalogDocsMetadata(ruleName, ruleModule)]);
+var decoratedRuleEntries = (0, import_ts_extras68.objectEntries)(baseRules).map(([ruleName, ruleModule]) => [ruleName, withCatalogDocsMetadata(ruleName, ruleModule)]);
 var decoratedRulesAccumulator = {};
 for (const [ruleName, ruleModule] of decoratedRuleEntries) {
   decoratedRulesAccumulator = {
@@ -8716,35 +9268,39 @@ var decoratedRules = decoratedRulesAccumulator;
 var rules = Object.freeze(decoratedRules);
 
 // dist/configs/all-strict.js
-var allStrictRuleEntries = (0, import_ts_extras66.objectEntries)(rules).map(([ruleName, ruleModule]) => [
+var allStrictRuleEntries = (0, import_ts_extras69.objectEntries)(rules).map(([ruleName, ruleModule]) => [
   `etc-misc/${ruleName}`,
   ruleModule.meta.deprecated === false ? "error" : "warn"
 ]);
-var allStrictRules = (0, import_ts_extras66.objectFromEntries)(allStrictRuleEntries);
+var allStrictRules = (0, import_ts_extras69.objectFromEntries)(allStrictRuleEntries);
 var allStrict = {
+  name: "etc-misc/all-strict",
   rules: allStrictRules
 };
 
 // dist/configs/all.js
-var import_ts_extras67 = require("ts-extras");
+var import_ts_extras70 = require("ts-extras");
 var getAllPresetSeverity = (ruleModule) => {
   if (ruleModule.meta.deprecated !== false) {
     return "warn";
   }
   return ruleModule.meta.type === "problem" ? "error" : "warn";
 };
-var allRuleEntries = (0, import_ts_extras67.objectEntries)(rules).map(([ruleName, ruleModule]) => [`etc-misc/${ruleName}`, getAllPresetSeverity(ruleModule)]);
-var allRules = (0, import_ts_extras67.objectFromEntries)(allRuleEntries);
+var allRuleEntries = (0, import_ts_extras70.objectEntries)(rules).map(([ruleName, ruleModule]) => [`etc-misc/${ruleName}`, getAllPresetSeverity(ruleModule)]);
+var allRules = (0, import_ts_extras70.objectFromEntries)(allRuleEntries);
 var all = {
+  name: "etc-misc/all",
   rules: allRules
 };
 
 // dist/configs/minimal.js
 var minimal = {
+  name: "etc-misc/minimal",
   rules: {
     "etc-misc/consistent-optional-props": "warn",
     "etc-misc/no-assign-mutated-array": "error",
     "etc-misc/no-const-enum": "warn",
+    "etc-misc/no-function-declare-after-return": "warn",
     "etc-misc/no-implicit-any-catch": "error",
     "etc-misc/no-internal": "error",
     "etc-misc/no-t": "error",
@@ -8752,6 +9308,7 @@ var minimal = {
     "etc-misc/no-unnecessary-break": "warn",
     "etc-misc/no-unnecessary-initialization": "warn",
     "etc-misc/no-unnecessary-template-literal": "warn",
+    "etc-misc/no-vulnerable": "error",
     "etc-misc/throw-error": "error",
     "etc-misc/typescript/no-boolean-literal-type": "error",
     "etc-misc/typescript/require-readonly-array-return-type": "warn",
@@ -8761,10 +9318,12 @@ var minimal = {
 
 // dist/configs/recommended.js
 var recommended = {
+  name: "etc-misc/recommended",
   rules: {
     "etc-misc/consistent-optional-props": "warn",
     "etc-misc/no-assign-mutated-array": "error",
     "etc-misc/no-const-enum": "warn",
+    "etc-misc/no-function-declare-after-return": "warn",
     "etc-misc/no-implicit-any-catch": "error",
     "etc-misc/no-internal": "error",
     "etc-misc/no-t": "error",
@@ -8772,6 +9331,7 @@ var recommended = {
     "etc-misc/no-unnecessary-break": "warn",
     "etc-misc/no-unnecessary-initialization": "warn",
     "etc-misc/no-unnecessary-template-literal": "warn",
+    "etc-misc/no-vulnerable": "error",
     "etc-misc/throw-error": "error",
     "etc-misc/typescript/no-boolean-literal-type": "error",
     "etc-misc/typescript/prefer-readonly-array": "warn",
@@ -8787,18 +9347,19 @@ var recommended = {
 };
 
 // dist/configs/strict-type-checked.js
-var import_ts_extras69 = require("ts-extras");
+var import_ts_extras72 = require("ts-extras");
 
 // dist/configs/strict.js
-var import_ts_extras68 = require("ts-extras");
-var recommendedRuleNames2 = (0, import_ts_extras68.safeCastTo)((0, import_ts_extras68.objectKeys)(recommended.rules));
-var strictRules = (0, import_ts_extras68.objectFromEntries)(recommendedRuleNames2.map((ruleName) => [ruleName, "error"]));
+var import_ts_extras71 = require("ts-extras");
+var recommendedRuleNames2 = (0, import_ts_extras71.safeCastTo)((0, import_ts_extras71.objectKeys)(recommended.rules));
+var strictRules = (0, import_ts_extras71.objectFromEntries)(recommendedRuleNames2.map((ruleName) => [ruleName, "error"]));
 var strict = {
+  name: "etc-misc/strict",
   rules: strictRules
 };
 
 // dist/configs/strict-type-checked.js
-var additionalTypeCheckedRuleEntries = (0, import_ts_extras69.objectEntries)(rules).flatMap(([ruleName, ruleModule]) => {
+var additionalTypeCheckedRuleEntries = (0, import_ts_extras72.objectEntries)(rules).flatMap(([ruleName, ruleModule]) => {
   if (ruleModule.meta.deprecated !== false) {
     return [];
   }
@@ -8807,14 +9368,14 @@ var additionalTypeCheckedRuleEntries = (0, import_ts_extras69.objectEntries)(rul
     return [];
   }
   const qualifiedRuleName = `etc-misc/${ruleName}`;
-  if ((0, import_ts_extras69.keyIn)(strict.rules, qualifiedRuleName)) {
+  if ((0, import_ts_extras72.keyIn)(strict.rules, qualifiedRuleName)) {
     return [];
   }
   return [[qualifiedRuleName, "error"]];
 });
 var strictTypeCheckedRules = {
   ...strict.rules,
-  ...(0, import_ts_extras69.objectFromEntries)(additionalTypeCheckedRuleEntries)
+  ...(0, import_ts_extras72.objectFromEntries)(additionalTypeCheckedRuleEntries)
 };
 var strictTypeChecked = {
   languageOptions: {
@@ -8822,6 +9383,7 @@ var strictTypeChecked = {
       projectService: true
     }
   },
+  name: "etc-misc/strict-type-checked",
   rules: strictTypeCheckedRules
 };
 
@@ -8831,6 +9393,7 @@ var pluginReference = {
   rules
 };
 var withPluginReference = (config) => ({
+  name: config.name,
   plugins: {
     [pluginMeta.namespace]: pluginReference
   },