eslint-plugin-etc-misc 1.1.3 → 1.1.5

package/dist/plugin.cjs

@@ -42,10 +42,10 @@ var pluginMeta = {
 };
 
 // dist/configs/all-strict.js
-var import_ts_extras69 = require("ts-extras");
+var import_ts_extras71 = require("ts-extras");
 
 // dist/rules.js
-var import_ts_extras68 = require("ts-extras");
+var import_ts_extras70 = require("ts-extras");
 
 // dist/_internal/rule-catalog.js
 var toCatalogNumericPart = (catalogIndex) => `${catalogIndex}`.padStart(3, "0");
@@ -92,6 +92,45 @@ var import_eslint_plugin = __toESM(require("@typescript-eslint/eslint-plugin"),
 var import_ts_extras = require("ts-extras");
 var isObjectRecord = (value) => typeof value === "object" && value !== null;
 var hasCreateFunction = (value) => isObjectRecord(value) && typeof value["create"] === "function";
+var isRuleMetaDocs = (value) => isObjectRecord(value) && typeof value["description"] === "string";
+var getNormalizedMetaType = (value) => {
+  if (value === "layout" || value === "problem" || value === "suggestion") {
+    return value;
+  }
+  return "problem";
+};
+var getNormalizedMetaMessages = (value) => {
+  if (!isObjectRecord(value)) {
+    return {};
+  }
+  let normalizedMessages = {};
+  for (const [key, message] of (0, import_ts_extras.objectEntries)(value)) {
+    if (typeof message !== "string") {
+      continue;
+    }
+    normalizedMessages = {
+      ...normalizedMessages,
+      [key]: message
+    };
+  }
+  return normalizedMessages;
+};
+var isJsonSchemaLike = (value) => {
+  if (!isObjectRecord(value)) {
+    return false;
+  }
+  return (0, import_ts_extras.keyIn)(value, "allOf") || (0, import_ts_extras.keyIn)(value, "anyOf") || (0, import_ts_extras.keyIn)(value, "oneOf") || (0, import_ts_extras.keyIn)(value, "properties") || (0, import_ts_extras.keyIn)(value, "type");
+};
+var isJsonSchemaArray = (value) => Array.isArray(value) && value.every((entry) => isJsonSchemaLike(entry));
+var getNormalizedMetaSchema = (value) => {
+  if (isJsonSchemaArray(value)) {
+    return value;
+  }
+  if (isJsonSchemaLike(value)) {
+    return value;
+  }
+  return [];
+};
 var createLegacyContextCompat = (context) => new Proxy(context, {
   get: (target, property, receiver) => {
     if (property === "getSourceCode") {
@@ -109,11 +148,11 @@ var createLegacyContextCompat = (context) => new Proxy(context, {
     return Reflect.get(target, property, receiver);
   }
 });
-var getExternalRuleFromPlugin = (plugin2, ruleName, pluginName) => {
-  if (!isObjectRecord(plugin2) || !isObjectRecord(plugin2["rules"])) {
+var getExternalRuleFromPlugin = (plugin3, ruleName, pluginName) => {
+  if (!isObjectRecord(plugin3) || !isObjectRecord(plugin3["rules"])) {
     throw new TypeError(`Plugin "${pluginName}" does not expose a valid rules map.`);
   }
-  const rules2 = plugin2["rules"];
+  const rules2 = plugin3["rules"];
   if (!(0, import_ts_extras.objectHasOwn)(rules2, ruleName)) {
     throw new Error(`Rule "${ruleName}" was not found in plugin "${pluginName}".`);
   }
@@ -124,19 +163,25 @@ var adaptExternalRule = (externalRule4, docsUrl) => {
     throw new TypeError("External rule module does not expose create().");
   }
   const externalRuleRecord = externalRule4;
-  const externalMeta = isObjectRecord(externalRuleRecord["meta"]) ? externalRuleRecord["meta"] : {};
-  const externalDocs = isObjectRecord(externalMeta["docs"]) ? externalMeta["docs"] : {};
+  const externalMetaRecord = isObjectRecord(externalRuleRecord["meta"]) ? externalRuleRecord["meta"] : {};
+  const externalDocs = isRuleMetaDocs(externalMetaRecord["docs"]) ? externalMetaRecord["docs"] : {
+    description: "External rule re-exported by eslint-plugin-etc-misc."
+  };
   const create = (context) => externalRule4.create(createLegacyContextCompat(context));
+  const externalRuleModule = (0, import_ts_extras.safeCastTo)(externalRuleRecord);
   return {
-    ...externalRuleRecord,
+    ...externalRuleModule,
     create,
     defaultOptions: Array.isArray(externalRuleRecord["defaultOptions"]) ? (0, import_ts_extras.safeCastTo)(externalRuleRecord["defaultOptions"]) : [],
     meta: {
-      ...externalMeta,
+      ...externalMetaRecord,
       docs: {
         ...externalDocs,
         url: docsUrl
-      }
+      },
+      messages: getNormalizedMetaMessages(externalMetaRecord["messages"]),
+      schema: getNormalizedMetaSchema(externalMetaRecord["schema"]),
+      type: getNormalizedMetaType(externalMetaRecord["type"])
     }
   };
 };
@@ -191,19 +236,20 @@ var deprecatedRule = withDeprecatedRuleLifecycle(rule, {
 var array_type_default = deprecatedRule;
 
 // dist/rules/class-match-filename.js
-var import_node_path = require("node:path");
+var import_node_path = __toESM(require("node:path"), 1);
 
 // dist/_internal/rule-creator.js
 var import_utils = require("@typescript-eslint/utils");
-var ruleCreator = import_utils.ESLintUtils.RuleCreator((name) => {
+var createRuleCreator = import_utils.ESLintUtils.RuleCreator;
+var ruleCreator = createRuleCreator((name) => {
   const docsPathName = name.replaceAll("/", "-");
   return `https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/${docsPathName}`;
 });
 
 // dist/rules/class-match-filename.js
 var getFileStem = (filePath) => {
-  const extension = (0, import_node_path.extname)(filePath);
-  return (0, import_node_path.basename)(filePath, extension);
+  const extension = import_node_path.default.extname(filePath);
+  return import_node_path.default.basename(filePath, extension);
 };
 var rule2 = ruleCreator({
   create: (context) => ({
@@ -247,13 +293,14 @@ var rule2 = ruleCreator({
 var class_match_filename_default = rule2;
 
 // dist/rules/comment-spacing.js
+var import_utils2 = require("@typescript-eslint/utils");
 var import_ts_extras3 = require("ts-extras");
-var isEslintDirectiveComment = (comment) => comment.type === "Block" && comment.value.trimStart().startsWith("eslint-");
+var isEslintDirectiveComment = (comment) => comment.type === import_utils2.AST_TOKEN_TYPES.Block && comment.value.trimStart().startsWith("eslint-");
 var expectedBlankLines = (comment) => {
-  if (comment.type === "Line" || isEslintDirectiveComment(comment)) {
+  if (comment.type === import_utils2.AST_TOKEN_TYPES.Line || isEslintDirectiveComment(comment)) {
     return 0;
   }
-  return /\r\n|\n/u.test(comment.value) ? 1 : 0;
+  return /\r\n|\n/v.test(comment.value) ? 1 : 0;
 };
 var buildFix = (sourceCode, comment, nextNode, expected) => (fixer) => {
   const textBetween = sourceCode.text.slice(comment.range[1], (0, import_ts_extras3.arrayFirst)(nextNode.range));
@@ -308,7 +355,7 @@ var comment_spacing_default = rule3;
 
 // dist/rules/consistent-empty-lines.js
 var import_ts_extras4 = require("ts-extras");
-var splitLines = (sourceText) => (0, import_ts_extras4.stringSplit)(sourceText.replaceAll(/\r\n?/gu, "\n"), "\n");
+var splitLines = (sourceText) => (0, import_ts_extras4.stringSplit)(sourceText.replaceAll(/\r\n?/gv, "\n"), "\n");
 var collapseEmptyLines = (sourceText) => {
   const lines = splitLines(sourceText);
   let output = [];
@@ -415,9 +462,9 @@ var import_ts_extras6 = require("ts-extras");
 
 // dist/_internal/identifier-blocks.js
 var import_ts_extras5 = require("ts-extras");
-var camelCaseBoundaryPattern = /(?<=[\da-z])(?=[A-Z])/gu;
-var nonAlphanumericPattern = /[^0-9A-Za-z]+/gu;
-var whitespacePattern = /\s+/gu;
+var camelCaseBoundaryPattern = /(?<=[\da-z])(?=[A-Z])/gv;
+var nonAlphanumericPattern = /[^0-9A-Za-z]+/gv;
+var whitespacePattern = /\s+/gv;
 var splitIdentifierBlocks = (value) => {
   const normalized = value.replaceAll(camelCaseBoundaryPattern, " ").replaceAll(nonAlphanumericPattern, " ").trim();
   if (normalized.length === 0) {
@@ -452,7 +499,7 @@ var filenameStem = (filePath) => {
   const normalizedPath = filePath.replaceAll("\\", "/");
   const pathSegments = (0, import_ts_extras6.stringSplit)(normalizedPath, "/");
   const lastPathSegment = (0, import_ts_extras6.arrayAt)(pathSegments, -1) ?? filePath;
-  return lastPathSegment.replace(/\.[^./\\]+$/u, "");
+  return lastPathSegment.replace(/\.[^.\/]+$/v, "");
 };
 
 // dist/rules/consistent-filename.js
@@ -534,14 +581,15 @@ var deprecatedRule2 = withDeprecatedRuleLifecycle(rule6, {
 var consistent_filename_default = deprecatedRule2;
 
 // dist/rules/consistent-import.js
+var import_utils3 = require("@typescript-eslint/utils");
 var import_ts_extras8 = require("ts-extras");
 var styleFromImport = (node) => {
   if (node.specifiers.length === 0) {
     return "side-effect";
   }
-  const hasDefault = node.specifiers.some((specifier) => specifier.type === "ImportDefaultSpecifier");
-  const hasNamed = node.specifiers.some((specifier) => specifier.type === "ImportSpecifier");
-  const hasNamespace = node.specifiers.some((specifier) => specifier.type === "ImportNamespaceSpecifier");
+  const hasDefault = node.specifiers.some((specifier) => specifier.type === import_utils3.AST_NODE_TYPES.ImportDefaultSpecifier);
+  const hasNamed = node.specifiers.some((specifier) => specifier.type === import_utils3.AST_NODE_TYPES.ImportSpecifier);
+  const hasNamespace = node.specifiers.some((specifier) => specifier.type === import_utils3.AST_NODE_TYPES.ImportNamespaceSpecifier);
   if (hasNamespace) {
     return "namespace";
   }
@@ -622,6 +670,7 @@ var rule7 = ruleCreator({
 var consistent_import_default = rule7;
 
 // dist/rules/consistent-optional-props.js
+var import_utils4 = require("@typescript-eslint/utils");
 var import_ts_extras9 = require("ts-extras");
 var selector2 = (0, import_ts_extras9.arrayJoin)([
   "TSPropertySignature[optional=true] > TSTypeAnnotation > TSUnionType",
@@ -630,7 +679,7 @@ var selector2 = (0, import_ts_extras9.arrayJoin)([
 var buildOptionalUnionFixText = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
-    if (typeNode.type === "TSUndefinedKeyword") {
+    if (typeNode.type === import_utils4.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     nonUndefinedTypeTexts = [
@@ -648,7 +697,7 @@ var rule8 = ruleCreator({
     const sourceCode = context.sourceCode;
     return {
       [selector2]: (node) => {
-        if (node.type !== "TSUnionType") {
+        if (node.type !== import_utils4.AST_NODE_TYPES.TSUnionType) {
           return;
         }
         const fixedTypeText = buildOptionalUnionFixText(sourceCode, node);
@@ -783,20 +832,21 @@ var default_case_default = rule11;
 var import_ts_extras11 = require("ts-extras");
 
 // dist/_internal/import-patterns.js
+var import_utils5 = require("@typescript-eslint/utils");
 var import_minimatch = require("minimatch");
 var matchesAnyPattern = (value, patterns) => patterns.some((pattern) => (0, import_minimatch.minimatch)(value, pattern, {
   dot: true,
   nocase: false
 }));
 var getImportSourceText = (node) => {
-  if (node.type === "ExportAllDeclaration" || node.type === "ImportDeclaration") {
+  if (node.type === import_utils5.AST_NODE_TYPES.ExportAllDeclaration || node.type === import_utils5.AST_NODE_TYPES.ImportDeclaration) {
     return node.source.value;
   }
-  if (node.type === "ExportNamedDeclaration") {
+  if (node.type === import_utils5.AST_NODE_TYPES.ExportNamedDeclaration) {
     return node.source?.value;
   }
-  if (node.type === "ImportExpression") {
-    return node.source.type === "Literal" && typeof node.source.value === "string" ? node.source.value : void 0;
+  if (node.type === import_utils5.AST_NODE_TYPES.ImportExpression) {
+    return node.source.type === import_utils5.AST_NODE_TYPES.Literal && typeof node.source.value === "string" ? node.source.value : void 0;
   }
   return void 0;
 };
@@ -880,24 +930,25 @@ var rule12 = createImportPatternRule({
 var disallow_import_default = rule12;
 
 // dist/rules/export-matching-filename-only.js
-var import_node_path2 = require("node:path");
+var import_utils6 = require("@typescript-eslint/utils");
+var import_node_path2 = __toESM(require("node:path"), 1);
 var import_ts_extras12 = require("ts-extras");
 var exportedNamesFromDeclaration = (node) => {
   if (node.specifiers.length > 0) {
-    return node.specifiers.filter((specifier) => specifier.type === "ExportSpecifier").flatMap((specifier) => specifier.exported.type === "Identifier" ? [specifier.exported.name] : []);
+    return node.specifiers.flatMap((specifier) => specifier.exported.type === import_utils6.AST_NODE_TYPES.Identifier ? [specifier.exported.name] : []);
   }
-  if (node.declaration?.type === "ClassDeclaration" || node.declaration?.type === "FunctionDeclaration") {
+  if (node.declaration?.type === import_utils6.AST_NODE_TYPES.ClassDeclaration || node.declaration?.type === import_utils6.AST_NODE_TYPES.FunctionDeclaration) {
     return node.declaration.id === null ? [] : [node.declaration.id.name];
   }
   return [];
 };
 var rule13 = ruleCreator({
   create: (context, [options]) => {
-    let exports2 = [];
+    let namedExports = [];
     return {
       ExportDefaultDeclaration: (node) => {
-        exports2 = [
-          ...exports2,
+        namedExports = [
+          ...namedExports,
           {
             name: "default",
             node
@@ -906,20 +957,20 @@ var rule13 = ruleCreator({
       },
       ExportNamedDeclaration: (node) => {
         for (const name of exportedNamesFromDeclaration(node)) {
-          exports2 = [...exports2, { name, node }];
+          namedExports = [...namedExports, { name, node }];
         }
       },
       "Program:exit": () => {
         if (context.filename === "<input>") {
           return;
         }
-        const stem = filenameStem((0, import_node_path2.resolve)(context.filename));
+        const stem = filenameStem(import_node_path2.default.resolve(context.filename));
         const expected = toCasing(stem, options.format ?? "PascalCase");
-        const matching = exports2.filter((entry) => entry.name === expected);
-        if ((0, import_ts_extras12.isEmpty)(matching) || exports2.length <= 1) {
+        const matching = namedExports.filter((entry) => entry.name === expected);
+        if ((0, import_ts_extras12.isEmpty)(matching) || namedExports.length <= 1) {
           return;
         }
-        for (const entry of exports2) {
+        for (const entry of namedExports) {
           if (entry.name === expected) {
             continue;
           }
@@ -973,7 +1024,8 @@ var rule13 = ruleCreator({
 var export_matching_filename_only_default = rule13;
 
 // dist/rules/match-filename.js
-var import_node_path3 = require("node:path");
+var import_utils7 = require("@typescript-eslint/utils");
+var import_node_path3 = __toESM(require("node:path"), 1);
 var import_ts_extras13 = require("ts-extras");
 var defaultSelectors = [
   "ClassDeclaration > Identifier.id",
@@ -998,10 +1050,10 @@ var rule14 = ruleCreator({
       listeners = {
         ...listeners,
         [selector25]: (node) => {
-          if (context.filename === "<input>" || node.type !== "Identifier") {
+          if (context.filename === "<input>" || node.type !== import_utils7.AST_NODE_TYPES.Identifier) {
             return;
           }
-          const stem = filenameStem((0, import_node_path3.resolve)(context.filename));
+          const stem = filenameStem(import_node_path3.default.resolve(context.filename));
           const expected = `${options.prefix ?? ""}${toCasing(node.name, options.format ?? "kebab-case")}${options.suffix ?? ""}`;
           const matches = stem === expected;
           if (options.match ?? true ? matches : !matches) {
@@ -1127,7 +1179,7 @@ var max_identifier_blocks_default = rule15;
 
 // dist/rules/no-assign-mutated-array.js
 var import_type_utils = require("@typescript-eslint/type-utils");
-var import_utils2 = require("@typescript-eslint/utils");
+var import_utils8 = require("@typescript-eslint/utils");
 var import_ts_extras15 = require("ts-extras");
 var readonlyArrayTypeNames = /* @__PURE__ */ new Set(["ReadonlyArray"]);
 var isArrayLikeType = (typeChecker, type) => {
@@ -1145,54 +1197,54 @@ var creatorMethodNames = /* @__PURE__ */ new Set([
   "values"
 ]);
 var isArrayFactoryCallee = (callee) => {
-  if (callee.type === "Identifier") {
+  if (callee.type === import_utils8.AST_NODE_TYPES.Identifier) {
     return callee.name === "Array";
   }
-  if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "Array" && callee.property.type === "Identifier") {
+  if (callee.type === import_utils8.AST_NODE_TYPES.MemberExpression && callee.object.type === import_utils8.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils8.AST_NODE_TYPES.Identifier) {
     return callee.property.name === "from" || callee.property.name === "of";
   }
   return false;
 };
 var isNewArray = (node) => {
-  if (node.type === "ArrayExpression") {
+  if (node.type === import_utils8.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (node.type === "CallExpression") {
+  if (node.type === import_utils8.AST_NODE_TYPES.CallExpression) {
     return isArrayFactoryCallee(node.callee);
   }
   return false;
 };
 var mutatesReferencedArray = (callExpression) => {
-  if (callExpression.callee.type !== "MemberExpression") {
+  if (callExpression.callee.type !== import_utils8.AST_NODE_TYPES.MemberExpression) {
     return true;
   }
   const { object, property } = callExpression.callee;
-  if (property.type === "Identifier" && (0, import_ts_extras15.setHas)(creatorMethodNames, property.name)) {
+  if (property.type === import_utils8.AST_NODE_TYPES.Identifier && (0, import_ts_extras15.setHas)(creatorMethodNames, property.name)) {
     return false;
   }
   if (isNewArray(object)) {
     return false;
   }
-  if (object.type === "CallExpression") {
+  if (object.type === import_utils8.AST_NODE_TYPES.CallExpression) {
     return mutatesReferencedArray(object);
   }
   return true;
 };
 var rule16 = ruleCreator({
   create: (context) => {
-    const parserServices = import_utils2.ESLintUtils.getParserServices(context);
+    const parserServices = import_utils8.ESLintUtils.getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
     return {
       "CallExpression[callee.type='MemberExpression'][callee.property.type='Identifier'][callee.property.name=/^(?:fill|reverse|sort)$/]": (callExpression) => {
         const { callee } = callExpression;
-        if (callee.type !== "MemberExpression") {
+        if (callee.type !== import_utils8.AST_NODE_TYPES.MemberExpression) {
           return;
         }
         const { property } = callee;
-        if (property.type !== "Identifier") {
+        if (property.type !== import_utils8.AST_NODE_TYPES.Identifier) {
           return;
         }
-        if (callExpression.parent?.type === "ExpressionStatement") {
+        if (callExpression.parent.type === import_utils8.AST_NODE_TYPES.ExpressionStatement) {
           return;
         }
         const objectType = (0, import_type_utils.getConstrainedTypeAtLocation)(parserServices, callee.object);
@@ -1279,6 +1331,7 @@ var no_chain_coalescence_mixture_default = rule19;
 
 // dist/rules/no-commented-out-code.js
 var import_parser = __toESM(require("@typescript-eslint/parser"), 1);
+var import_utils9 = require("@typescript-eslint/utils");
 var import_ts_extras16 = require("ts-extras");
 var parserOptions = {
   ecmaVersion: "latest",
@@ -1320,7 +1373,7 @@ var toCommentBlocks = (comments) => {
   let blocks = [];
   let previousLineComment = null;
   for (const comment of comments) {
-    if (comment.type === "Block") {
+    if (comment.type === import_utils9.AST_TOKEN_TYPES.Block) {
       blocks = [
         ...blocks,
         {
@@ -1356,10 +1409,10 @@ ${comment.value}`,
   return blocks;
 };
 var isExpressionOrIdentifierOrLiteral = (node) => {
-  if (node.type === "Identifier" || node.type === "Literal") {
+  if (node.type === import_utils9.AST_NODE_TYPES.Identifier || node.type === import_utils9.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (node.type !== "BinaryExpression") {
+  if (node.type !== import_utils9.AST_NODE_TYPES.BinaryExpression) {
     return false;
   }
   return isExpressionOrIdentifierOrLiteral(node.left) && isExpressionOrIdentifierOrLiteral(node.right);
@@ -1368,37 +1421,37 @@ var isTrivialProgram = (program) => {
   if (program.body.length === 0) {
     return true;
   }
-  if (program.body.length === 1 && (0, import_ts_extras16.arrayFirst)(program.body)?.type === "LabeledStatement") {
+  if (program.body.length === 1 && (0, import_ts_extras16.arrayFirst)(program.body)?.type === import_utils9.AST_NODE_TYPES.LabeledStatement) {
     return true;
   }
-  return program.body.every((statement) => statement.type === "ExpressionStatement" && isExpressionOrIdentifierOrLiteral(statement.expression));
+  return program.body.every((statement) => statement.type === import_utils9.AST_NODE_TYPES.ExpressionStatement && isExpressionOrIdentifierOrLiteral(statement.expression));
 };
 var getWrappedContent = (content, node) => {
   if (node === null) {
     return void 0;
   }
-  if (node.type === "ArrayExpression") {
+  if (node.type === import_utils9.AST_NODE_TYPES.ArrayExpression) {
     return `const wrapper = [${content}]`;
   }
-  if (node.type === "ClassBody") {
+  if (node.type === import_utils9.AST_NODE_TYPES.ClassBody) {
     return `class Wrapper { ${content} }`;
   }
-  if (node.type === "FunctionDeclaration") {
+  if (node.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration) {
     return `function wrapper(${content}) {}`;
   }
-  if (node.type === "ImportDeclaration") {
+  if (node.type === import_utils9.AST_NODE_TYPES.ImportDeclaration) {
     return `import { ${content} } from "wrapper"`;
   }
-  if (node.type === "ObjectExpression") {
+  if (node.type === import_utils9.AST_NODE_TYPES.ObjectExpression) {
     return `const wrapper = { ${content} }`;
   }
-  if (node.type === "SwitchStatement") {
+  if (node.type === import_utils9.AST_NODE_TYPES.SwitchStatement) {
     return `switch (wrapper) { ${content} }`;
   }
-  if (node.type === "TSInterfaceBody") {
+  if (node.type === import_utils9.AST_NODE_TYPES.TSInterfaceBody) {
     return `interface Wrapper { ${content} }`;
   }
-  if (node.type === "TSTypeLiteral") {
+  if (node.type === import_utils9.AST_NODE_TYPES.TSTypeLiteral) {
     return `type Wrapper = { ${content} }`;
   }
   return void 0;
@@ -1479,9 +1532,10 @@ var deprecatedRule4 = withDeprecatedRuleLifecycle(rule20, {
 var no_commented_out_code_default = deprecatedRule4;
 
 // dist/rules/no-const-enum.js
+var import_utils10 = require("@typescript-eslint/utils");
 var import_ts_extras17 = require("ts-extras");
 var defaultOptions2 = [{}];
-var isExportedEnumDeclaration = (node) => node.parent?.type === "ExportNamedDeclaration";
+var isExportedEnumDeclaration = (node) => node.parent.type === import_utils10.AST_NODE_TYPES.ExportNamedDeclaration;
 var getConstToken = (sourceCode, node) => sourceCode.getFirstToken(node, {
   filter: (token) => token.value === "const"
 }) ?? void 0;
@@ -1561,7 +1615,7 @@ var rule21 = ruleCreator({
 var no_const_enum_default = rule21;
 
 // dist/rules/no-deprecated.js
-var import_utils3 = require("@typescript-eslint/utils");
+var import_utils12 = require("@typescript-eslint/utils");
 var import_ts_extras20 = require("ts-extras");
 
 // dist/_internal/ignore-patterns.js
@@ -1593,20 +1647,21 @@ var compileIgnorePatterns = (ignored) => {
 
 // dist/_internal/symbol-usage.js
 var import_type_utils2 = require("@typescript-eslint/type-utils");
+var import_utils11 = require("@typescript-eslint/utils");
 var import_ts_extras19 = require("ts-extras");
-var isImportOrExportSpecifier = (parent) => parent?.type === "ExportSpecifier" || parent?.type === "ImportDefaultSpecifier" || parent?.type === "ImportNamespaceSpecifier" || parent?.type === "ImportSpecifier";
+var isImportOrExportSpecifier = (parent) => parent?.type === import_utils11.AST_NODE_TYPES.ExportSpecifier || parent?.type === import_utils11.AST_NODE_TYPES.ImportDefaultSpecifier || parent?.type === import_utils11.AST_NODE_TYPES.ImportNamespaceSpecifier || parent?.type === import_utils11.AST_NODE_TYPES.ImportSpecifier;
 var isDeclarationIdentifier = (node) => {
   const { parent } = node;
-  if (parent === void 0) {
+  if (!(0, import_ts_extras19.isDefined)(parent)) {
     return false;
   }
-  if (parent.type === "TSInterfaceDeclaration" || parent.type === "TSTypeAliasDeclaration") {
+  if (parent.type === import_utils11.AST_NODE_TYPES.TSInterfaceDeclaration || parent.type === import_utils11.AST_NODE_TYPES.TSTypeAliasDeclaration) {
     return parent.id === node;
   }
-  if (parent.type === "ClassDeclaration" || parent.type === "FunctionDeclaration" || parent.type === "TSDeclareFunction" || parent.type === "TSEnumDeclaration") {
+  if (parent.type === import_utils11.AST_NODE_TYPES.ClassDeclaration || parent.type === import_utils11.AST_NODE_TYPES.FunctionDeclaration || parent.type === import_utils11.AST_NODE_TYPES.TSDeclareFunction || parent.type === import_utils11.AST_NODE_TYPES.TSEnumDeclaration) {
     return parent.id === node;
   }
-  if (parent.type === "VariableDeclarator") {
+  if (parent.type === import_utils11.AST_NODE_TYPES.VariableDeclarator) {
     return parent.id === node;
   }
   return false;
@@ -1616,10 +1671,10 @@ var normalizeTagComment = (text) => {
     return void 0;
   }
   if (typeof text === "string") {
-    const normalized2 = text.trim().replaceAll(/\s+/gu, " ");
+    const normalized2 = text.trim().replaceAll(/\s+/gv, " ");
     return normalized2.length > 0 ? normalized2 : void 0;
   }
-  const normalized = (0, import_ts_extras19.arrayJoin)(text.map((part) => part.text), "").replaceAll(/\s+/gu, " ").trim();
+  const normalized = (0, import_ts_extras19.arrayJoin)(text.map((part) => part.text), "").replaceAll(/\s+/gv, " ").trim();
   return normalized.length > 0 ? normalized : void 0;
 };
 var isUnknownRecord = (value) => typeof value === "object" && value !== null;
@@ -1654,7 +1709,7 @@ var defaultOptions3 = [{}];
 var rule22 = ruleCreator({
   create: (context) => {
     const [{ ignored = {} } = {}] = context.options;
-    const parserServices = import_utils3.ESLintUtils.getParserServices(context);
+    const parserServices = import_utils12.ESLintUtils.getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
     const compiledIgnorePatterns = compileIgnorePatterns(ignored);
     const ignorePatterns = compiledIgnorePatterns.patterns;
@@ -1804,7 +1859,7 @@ var no_enum_default = rule23;
 
 // dist/rules/no-expression-empty-lines.js
 var import_ts_extras21 = require("ts-extras");
-var splitLines2 = (sourceText) => (0, import_ts_extras21.stringSplit)(sourceText.replaceAll(/\r\n?/gu, "\n"), "\n");
+var splitLines2 = (sourceText) => (0, import_ts_extras21.stringSplit)(sourceText.replaceAll(/\r\n?/gv, "\n"), "\n");
 var hasBlankLine = (text) => splitLines2(text).some((line) => line.trim().length === 0);
 var normalizeExpressionSource = (sourceText) => {
   const lines = splitLines2(sourceText).map((line) => line.trimEnd());
@@ -1852,7 +1907,7 @@ var no_expression_empty_lines_default = rule24;
 
 // dist/rules/no-foreach.js
 var import_type_utils3 = require("@typescript-eslint/type-utils");
-var import_utils4 = require("@typescript-eslint/utils");
+var import_utils13 = require("@typescript-eslint/utils");
 var import_ts_extras22 = require("ts-extras");
 var defaultOptions4 = [{}];
 var defaultTypes = [
@@ -1882,14 +1937,14 @@ var matchesConfiguredCollectionType = (typeChecker, type, configuredTypeNames) =
 };
 var rule25 = ruleCreator({
   create: (context) => {
-    const parserServices = import_utils4.ESLintUtils.getParserServices(context);
+    const parserServices = import_utils13.ESLintUtils.getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
     const [{ types = defaultTypes } = {}] = context.options;
     const configuredTypeNames = getConfiguredTypeNames(types);
     return {
       "CallExpression[callee.type='MemberExpression'][callee.property.type='Identifier'][callee.property.name='forEach']": (callExpression) => {
         const { callee } = callExpression;
-        if (callee.type !== "MemberExpression") {
+        if (callee.type !== import_utils13.AST_NODE_TYPES.MemberExpression) {
           return;
         }
         const objectType = (0, import_type_utils3.getConstrainedTypeAtLocation)(parserServices, callee.object);
@@ -1942,25 +1997,26 @@ var rule25 = ruleCreator({
 var no_foreach_default = rule25;
 
 // dist/rules/no-function-declare-after-return.js
+var import_utils14 = require("@typescript-eslint/utils");
 var import_ts_extras23 = require("ts-extras");
-var isStatementList = (node) => node.type === "BlockStatement" || node.type === "Program";
+var isStatementList = (node) => node.type === import_utils14.AST_NODE_TYPES.BlockStatement || node.type === import_utils14.AST_NODE_TYPES.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 declarationStart = (0, import_ts_extras23.arrayFirst)(node.range);
   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 tokenBeforeEnd = tokenBeforeDeclaration === null ? 0 : (0, import_ts_extras23.arrayLast)(tokenBeforeDeclaration.range);
+  const commentsBeforeDeclaration = sourceCode.getCommentsBefore(node).filter((comment) => (0, import_ts_extras23.arrayFirst)(comment.range) >= tokenBeforeEnd && (0, import_ts_extras23.arrayLast)(comment.range) <= declarationStart);
   const firstLeadingComment = (0, import_ts_extras23.arrayFirst)(commentsBeforeDeclaration);
-  const firstMovableNodeStart = firstLeadingComment === void 0 ? declarationStart : (0, import_ts_extras23.arrayFirst)(firstLeadingComment.range) ?? declarationStart;
+  const firstMovableNodeStart = firstLeadingComment === void 0 ? declarationStart : (0, import_ts_extras23.arrayFirst)(firstLeadingComment.range);
   return getLineStartIndex(sourceCode.text, firstMovableNodeStart);
 };
 var getSafeFixRangeEnd = (sourceCode, node) => {
-  const declarationEnd = (0, import_ts_extras23.arrayLast)(node.range) ?? 0;
+  const declarationEnd = (0, import_ts_extras23.arrayLast)(node.range);
   const tokenAfterDeclaration = sourceCode.getTokenAfter(node);
   if (tokenAfterDeclaration === null) {
     return declarationEnd;
   }
-  return getLineStartIndex(sourceCode.text, (0, import_ts_extras23.arrayFirst)(tokenAfterDeclaration.range) ?? declarationEnd);
+  return getLineStartIndex(sourceCode.text, (0, import_ts_extras23.arrayFirst)(tokenAfterDeclaration.range));
 };
 var rule26 = ruleCreator({
   create: (context) => ({
@@ -1973,18 +2029,18 @@ var rule26 = ruleCreator({
       const returnIndex = siblings.indexOf(node);
       for (let i = returnIndex + 1; i < siblings.length; i++) {
         const sibling = siblings[i];
-        if (sibling?.type !== "FunctionDeclaration") {
+        if (sibling?.type !== import_utils14.AST_NODE_TYPES.FunctionDeclaration) {
           continue;
         }
         const functionDeclaration = sibling;
         const returnStatement = node;
         context.report({
           data: {
-            name: functionDeclaration.id?.name ?? "(anonymous)"
+            name: functionDeclaration.id.name
           },
           fix(fixer) {
             const sourceCode = context.sourceCode;
-            const declarationEnd = (0, import_ts_extras23.arrayLast)(functionDeclaration.range) ?? 0;
+            const declarationEnd = (0, import_ts_extras23.arrayLast)(functionDeclaration.range);
             const fixRangeStart = getSafeFixRangeStart(sourceCode, functionDeclaration);
             const fixRangeEnd = getSafeFixRangeEnd(sourceCode, functionDeclaration);
             const functionAndLeadingCommentsText = sourceCode.text.slice(fixRangeStart, declarationEnd);
@@ -1992,7 +2048,10 @@ var rule26 = ruleCreator({
               return null;
             }
             const returnToken = sourceCode.getFirstToken(returnStatement);
-            const indentationEnd = (0, import_ts_extras23.arrayFirst)(returnToken?.range ?? [0]) ?? 0;
+            if (returnToken === null) {
+              return null;
+            }
+            const indentationEnd = (0, import_ts_extras23.arrayFirst)(returnToken.range);
             const returnLineStart = getLineStartIndex(sourceCode.text, indentationEnd);
             return [
               fixer.insertTextBeforeRange([returnLineStart, returnLineStart], `${functionAndLeadingCommentsText}
@@ -2029,12 +2088,12 @@ 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_utils15 = require("@typescript-eslint/utils");
 var import_ts_extras24 = require("ts-extras");
 var defaultOptions5 = [{}];
 var isPromiseRejectionCall = (callExpression, parserServices, program) => {
   const { callee } = callExpression;
-  if (callee.type !== "MemberExpression" || callee.object.type === "Super") {
+  if (callee.type !== import_utils15.AST_NODE_TYPES.MemberExpression || callee.object.type === import_utils15.AST_NODE_TYPES.Super) {
     return false;
   }
   const objectType = (0, import_type_utils4.getConstrainedTypeAtLocation)(parserServices, callee.object);
@@ -2060,15 +2119,15 @@ var annotateImplicitParamFixes = (fixer, sourceCode, parameter) => {
 };
 var rule27 = ruleCreator({
   create: (context) => {
-    const parserServices = import_utils5.ESLintUtils.getParserServices(context);
+    const parserServices = import_utils15.ESLintUtils.getParserServices(context);
     const sourceCode = context.sourceCode;
     const [{ allowExplicitAny = false } = {}] = context.options;
     const checkRejectionCallback = (callExpression, callback) => {
-      if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") {
+      if (callback.type !== import_utils15.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils15.AST_NODE_TYPES.FunctionExpression) {
         return;
       }
       const [parameter] = callback.params;
-      if (parameter?.type !== "Identifier") {
+      if (parameter?.type !== import_utils15.AST_NODE_TYPES.Identifier) {
         return;
       }
       if (!isPromiseRejectionCall(callExpression, parserServices, parserServices.program)) {
@@ -2090,10 +2149,10 @@ var rule27 = ruleCreator({
       }
       const { typeAnnotation } = parameter;
       const annotationType = typeAnnotation.typeAnnotation.type;
-      if (annotationType === "TSUnknownKeyword") {
+      if (annotationType === import_utils15.AST_NODE_TYPES.TSUnknownKeyword) {
         return;
       }
-      if (annotationType === "TSAnyKeyword") {
+      if (annotationType === import_utils15.AST_NODE_TYPES.TSAnyKeyword) {
         if (allowExplicitAny) {
           return;
         }
@@ -2197,13 +2256,13 @@ var rule29 = createImportPatternRule({
 var no_internal_modules_default = rule29;
 
 // dist/rules/no-internal.js
-var import_utils6 = require("@typescript-eslint/utils");
+var import_utils16 = require("@typescript-eslint/utils");
 var import_ts_extras25 = require("ts-extras");
 var defaultOptions6 = [{}];
 var rule30 = ruleCreator({
   create: (context) => {
     const [{ ignored = {} } = {}] = context.options;
-    const parserServices = import_utils6.ESLintUtils.getParserServices(context);
+    const parserServices = import_utils16.ESLintUtils.getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
     const compiledIgnorePatterns = compileIgnorePatterns(ignored);
     const ignorePatterns = compiledIgnorePatterns.patterns;
@@ -2342,7 +2401,7 @@ var rule31 = ruleCreator({
 var no_language_mixing_default = rule31;
 
 // dist/rules/no-misused-generics.js
-var import_utils7 = require("@typescript-eslint/utils");
+var import_utils17 = require("@typescript-eslint/utils");
 var import_ts_extras27 = require("ts-extras");
 var tsutils = __toESM(require("tsutils"), 1);
 var getVariableUses = (usageMap, identifier) => usageMap.get(identifier)?.uses ?? [];
@@ -2414,7 +2473,7 @@ var analyzeTypeParameterUses = (uses, signature, typeParameters) => {
 };
 var rule32 = ruleCreator({
   create: (context) => {
-    const parserServices = import_utils7.ESLintUtils.getParserServices(context);
+    const parserServices = import_utils17.ESLintUtils.getParserServices(context);
     let usageMap = null;
     const checkTypeParameters = (typeParameters, signature) => {
       usageMap ??= tsutils.collectVariableUsage(signature.getSourceFile());
@@ -2435,7 +2494,7 @@ var rule32 = ruleCreator({
           });
           continue;
         }
-        if (!usageAnalysis.usedInReturnOrExtends && usageMap !== null && !isConstrainedByAnotherTypeParameter(typeParameter, typeParameters, usageMap)) {
+        if (!usageAnalysis.usedInReturnOrExtends && !isConstrainedByAnotherTypeParameter(typeParameter, typeParameters, usageMap)) {
           context.report({
             data: {
               name: typeParameter.name.text,
@@ -2563,9 +2622,10 @@ var rule35 = createImportPatternRule({
 var no_nodejs_modules_default = rule35;
 
 // dist/rules/no-param-reassign.js
+var import_utils18 = require("@typescript-eslint/utils");
 var import_ts_extras29 = require("ts-extras");
 var getAssignmentTargetIdentifier = (node) => {
-  if (node.left.type === "Identifier") {
+  if (node.left.type === import_utils18.AST_NODE_TYPES.Identifier) {
     return node.left;
   }
   return void 0;
@@ -2581,7 +2641,7 @@ var getScopeVariable = (sourceCode, identifier) => {
   }
   return void 0;
 };
-var isParameterVariable = (variable) => variable?.defs.some((definition) => definition.type === "Parameter") ?? false;
+var isParameterVariable = (variable) => variable?.defs.some((definition) => definition.type === import_utils18.TSESLint.Scope.DefinitionType.Parameter) ?? false;
 var isInFirstFunctionExpressionStatement = (sourceCode, node) => {
   const ancestors = sourceCode.getAncestors(node);
   let enclosingFunction = null;
@@ -2590,16 +2650,16 @@ var isInFirstFunctionExpressionStatement = (sourceCode, node) => {
     if (ancestor === void 0) {
       continue;
     }
-    if (ancestor.type === "ArrowFunctionExpression" || ancestor.type === "FunctionDeclaration" || ancestor.type === "FunctionExpression") {
+    if (ancestor.type === import_utils18.AST_NODE_TYPES.ArrowFunctionExpression || ancestor.type === import_utils18.AST_NODE_TYPES.FunctionDeclaration || ancestor.type === import_utils18.AST_NODE_TYPES.FunctionExpression) {
       enclosingFunction = ancestor;
       break;
     }
   }
-  if (enclosingFunction?.body.type !== "BlockStatement") {
+  if (enclosingFunction?.body.type !== import_utils18.AST_NODE_TYPES.BlockStatement) {
     return false;
   }
   const [firstStatement] = enclosingFunction.body.body;
-  if (firstStatement?.type !== "ExpressionStatement") {
+  if (firstStatement?.type !== import_utils18.AST_NODE_TYPES.ExpressionStatement) {
     return false;
   }
   return (0, import_ts_extras29.arrayFirst)(node.range) >= (0, import_ts_extras29.arrayFirst)(firstStatement.range) && node.range[1] <= firstStatement.range[1];
@@ -2629,7 +2689,7 @@ var rule36 = ruleCreator({
         reportIfParameterReassignment(identifier);
       },
       UpdateExpression: (node) => {
-        if (node.argument.type !== "Identifier") {
+        if (node.argument.type !== import_utils18.AST_NODE_TYPES.Identifier) {
           return;
         }
         reportIfParameterReassignment(node.argument);
@@ -2696,7 +2756,7 @@ var import_ts_extras31 = require("ts-extras");
 
 // dist/_internal/syntax-selectors.js
 var import_ts_extras30 = require("ts-extras");
-var isSelectorObject = (value) => typeof value === "object" && value !== null && (0, import_ts_extras30.keyIn)(value, "selector");
+var isSelectorObject = (value) => typeof value === "object" && (0, import_ts_extras30.keyIn)(value, "selector");
 var normalizeSyntaxSelector = (selector25) => {
   if (isSelectorObject(selector25)) {
     if (!(0, import_ts_extras30.isDefined)(selector25.message)) {
@@ -2848,31 +2908,31 @@ var deprecatedRule9 = withDeprecatedRuleLifecycle(rule39, {
 var no_secret_default = deprecatedRule9;
 
 // dist/rules/no-self-import.js
-var import_node_path4 = require("node:path");
+var import_node_path4 = __toESM(require("node:path"), 1);
 var import_ts_extras32 = require("ts-extras");
 var importFileSuffixes = [
   "",
-  ".ts",
-  ".tsx",
-  ".js",
-  ".mjs",
   ".cjs",
   ".d.ts",
-  "/index.ts",
-  "/index.tsx",
+  ".js",
+  ".mjs",
+  ".ts",
+  ".tsx",
+  "/index.cjs",
   "/index.js",
   "/index.mjs",
-  "/index.cjs"
+  "/index.ts",
+  "/index.tsx"
 ];
-var toResolvedCandidates = (baseDirectory, importSource) => importFileSuffixes.map((suffix) => (0, import_node_path4.resolve)(baseDirectory, `${importSource}${suffix}`));
+var toResolvedCandidates = (baseDirectory, importSource) => importFileSuffixes.map((suffix) => import_node_path4.default.resolve(baseDirectory, `${importSource}${suffix}`));
 var rule40 = ruleCreator({
   create: (context) => {
     const currentFilePath = context.filename;
     if (currentFilePath === "<input>") {
       return {};
     }
-    const normalizedCurrentFilePath = (0, import_node_path4.resolve)(currentFilePath);
-    const currentFileDirectory = (0, import_node_path4.dirname)(normalizedCurrentFilePath);
+    const normalizedCurrentFilePath = import_node_path4.default.resolve(currentFilePath);
+    const currentFileDirectory = import_node_path4.default.dirname(normalizedCurrentFilePath);
     return {
       "ImportDeclaration, ExportNamedDeclaration[source], ExportAllDeclaration, ImportExpression": (node) => {
         const sourceText = getImportSourceFromNode(node);
@@ -2926,7 +2986,8 @@ var deprecatedRule10 = withDeprecatedRuleLifecycle(rule40, {
 var no_self_import_default = deprecatedRule10;
 
 // dist/rules/no-shadow.js
-var shouldIgnoreVariable = (variable) => variable.defs.some((definition) => definition.node.type === "TSEnumDeclaration" || definition.type.includes("Enum"));
+var import_utils19 = require("@typescript-eslint/utils");
+var shouldIgnoreVariable = (variable) => variable.defs.some((definition) => definition.node.type === import_utils19.AST_NODE_TYPES.TSEnumDeclaration || definition.type.includes("Enum"));
 var findShadowedVariable = (scope, variableName) => {
   let upperScope = scope.upper;
   while (upperScope !== null) {
@@ -3015,7 +3076,8 @@ var rule42 = createImportPatternRule({
 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;
+var import_utils20 = require("@typescript-eslint/utils");
+var directiveCommentPattern = /^(?:eslint(?:-|$)|global\s|exported\s|ts-(?:check|expect-error|ignore|nocheck))/v;
 var isDirectiveComment = (commentText2) => directiveCommentPattern.test(commentText2.trimStart());
 var createConvertToBlockSuggestionFix = (commentValue, commentRange) => {
   if (commentValue.includes("*/")) {
@@ -3029,7 +3091,7 @@ var rule43 = ruleCreator({
     return {
       Program: () => {
         for (const comment of context.sourceCode.getAllComments()) {
-          if (comment.type !== "Line") {
+          if (comment.type !== import_utils20.AST_TOKEN_TYPES.Line) {
             continue;
           }
           if (allowDirectiveComments && isDirectiveComment(comment.value)) {
@@ -3187,9 +3249,10 @@ var rule45 = ruleCreator({
 var no_underscore_export_default = rule45;
 
 // dist/rules/no-unnecessary-as-const.js
+var import_utils21 = require("@typescript-eslint/utils");
 var disallowedSelector7 = "VariableDeclarator > TSAsExpression[expression.properties.length=0] > TSTypeReference > Identifier[name='const'], VariableDeclarator[id.typeAnnotation] > TSAsExpression > TSTypeReference > Identifier[name='const']";
 var getAsConstExpression = (node) => {
-  if (node.type !== "Identifier" || node.parent?.type !== "TSTypeReference" || node.parent.parent?.type !== "TSAsExpression") {
+  if (node.type !== import_utils21.AST_NODE_TYPES.Identifier || node.parent.type !== import_utils21.AST_NODE_TYPES.TSTypeReference || node.parent.parent.type !== import_utils21.AST_NODE_TYPES.TSAsExpression) {
     return void 0;
   }
   return node.parent.parent;
@@ -3234,6 +3297,7 @@ var rule46 = ruleCreator({
 var no_unnecessary_as_const_default = rule46;
 
 // dist/rules/no-unnecessary-break.js
+var import_utils22 = require("@typescript-eslint/utils");
 var import_ts_extras34 = require("ts-extras");
 var disallowedSelector8 = "SwitchCase:last-child > BreakStatement.consequent";
 var createTrailingBreakRemovalFix = (sourceCode, node) => {
@@ -3245,7 +3309,7 @@ var createTrailingBreakRemovalFix = (sourceCode, node) => {
     return (fixer) => fixer.remove(node);
   }
   const leadingText = sourceCode.text.slice(previousToken.range[1], (0, import_ts_extras34.arrayFirst)(node.range));
-  const leadingWhitespaceLength = /^[\t ]*/u.exec(leadingText)?.[0].length ?? 0;
+  const leadingWhitespaceLength = /^[\t ]*/v.exec(leadingText)?.[0].length ?? 0;
   return (fixer) => fixer.removeRange([
     (0, import_ts_extras34.arrayFirst)(node.range) - leadingWhitespaceLength,
     node.range[1]
@@ -3256,7 +3320,7 @@ var rule47 = ruleCreator({
     const sourceCode = context.sourceCode;
     return {
       [disallowedSelector8]: (node) => {
-        if (node.type !== "BreakStatement" || node.label !== null) {
+        if (node.type !== import_utils22.AST_NODE_TYPES.BreakStatement || node.label !== null) {
           return;
         }
         const fix = createTrailingBreakRemovalFix(sourceCode, node);
@@ -3357,13 +3421,14 @@ var rule48 = ruleCreator({
 var no_unnecessary_initialization_default = rule48;
 
 // dist/rules/no-unnecessary-template-literal.js
+var import_utils23 = require("@typescript-eslint/utils");
 var import_ts_extras36 = require("ts-extras");
 var selector3 = "TemplateLiteral[expressions.length=0] > TemplateElement";
 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;
+      const templateLiteral = node.type === import_utils23.AST_NODE_TYPES.TemplateElement && node.parent.type === import_utils23.AST_NODE_TYPES.TemplateLiteral ? node.parent : void 0;
       if (templateLiteral === void 0) {
         return;
       }
@@ -3417,6 +3482,7 @@ var deprecatedRule12 = withDeprecatedRuleLifecycle(rule50, {
 var no_unused_disable_default = deprecatedRule12;
 
 // dist/rules/no-use-extend-native.js
+var import_utils24 = require("@typescript-eslint/utils");
 var import_ts_extras37 = require("ts-extras");
 var nativeTypeDefinitions = [
   {
@@ -3504,6 +3570,7 @@ var nativeTypeDefinitions = [
   }
 ];
 var nativeTypeNameSet = new Set(nativeTypeDefinitions.map((definition) => definition.name));
+var nativeTypeNameLookup = nativeTypeNameSet;
 function buildNativeTypeInfoByName(definitions) {
   return new Map(definitions.map((definition) => [
     definition.name,
@@ -3515,8 +3582,8 @@ function buildNativeTypeInfoByName(definitions) {
 function collectPropertyKinds(definition) {
   const propertyKinds = /* @__PURE__ */ new Map();
   const descriptorSources = [
-    definition.prototypeRef,
-    definition.constructorRef
+    definition.constructorRef,
+    definition.prototypeRef
   ];
   for (const descriptorSource of descriptorSources) {
     if (!(0, import_ts_extras37.isDefined)(descriptorSource)) {
@@ -3542,38 +3609,38 @@ function collectPropertyKinds(definition) {
   return propertyKinds;
 }
 function unwrapExpression(node) {
-  if (node.type === "TSAsExpression" || node.type === "TSTypeAssertion") {
+  if (node.type === import_utils24.AST_NODE_TYPES.TSAsExpression || node.type === import_utils24.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression(node.expression);
   }
-  if (node.type === "ChainExpression") {
+  if (node.type === import_utils24.AST_NODE_TYPES.ChainExpression) {
     return unwrapExpression(node.expression);
   }
   return node;
 }
 var inferNativeType = (rawExpression) => {
   const expression = unwrapExpression(rawExpression);
-  if (expression.type === "ArrayExpression") {
+  if (expression.type === import_utils24.AST_NODE_TYPES.ArrayExpression) {
     return "Array";
   }
-  if (expression.type === "ObjectExpression") {
+  if (expression.type === import_utils24.AST_NODE_TYPES.ObjectExpression) {
     return "Object";
   }
-  if (expression.type === "TemplateLiteral") {
+  if (expression.type === import_utils24.AST_NODE_TYPES.TemplateLiteral) {
     return "String";
   }
-  if (expression.type === "Literal") {
+  if (expression.type === import_utils24.AST_NODE_TYPES.Literal) {
     return inferNativeTypeFromLiteral(expression);
   }
-  if (expression.type === "Identifier" && isNativeTypeName(expression.name)) {
+  if (expression.type === import_utils24.AST_NODE_TYPES.Identifier && isNativeTypeName(expression.name)) {
     return expression.name;
   }
-  if (expression.type === "BinaryExpression") {
+  if (expression.type === import_utils24.AST_NODE_TYPES.BinaryExpression) {
     return inferNativeTypeFromBinaryExpression(expression);
   }
-  if (expression.type === "MemberExpression") {
+  if (expression.type === import_utils24.AST_NODE_TYPES.MemberExpression) {
     return inferNativeTypeFromMemberExpression(expression);
   }
-  if (expression.type === "NewExpression") {
+  if (expression.type === import_utils24.AST_NODE_TYPES.NewExpression) {
     return inferNativeTypeFromNewExpression(expression);
   }
   return null;
@@ -3611,13 +3678,13 @@ function inferNativeTypeFromLiteral(expression) {
   return null;
 }
 function inferNativeTypeFromMemberExpression(expression) {
-  if (expression.computed || expression.property.type !== "Identifier" || expression.property.name !== "prototype" || expression.object.type !== "Identifier" || !isNativeTypeName(expression.object.name)) {
+  if (expression.computed || expression.property.type !== import_utils24.AST_NODE_TYPES.Identifier || expression.property.name !== "prototype" || expression.object.type !== import_utils24.AST_NODE_TYPES.Identifier || !isNativeTypeName(expression.object.name)) {
     return null;
   }
   return expression.object.name;
 }
 function inferNativeTypeFromNewExpression(expression) {
-  if (expression.callee.type !== "Identifier" || !isNativeTypeName(expression.callee.name)) {
+  if (expression.callee.type !== import_utils24.AST_NODE_TYPES.Identifier || !isNativeTypeName(expression.callee.name)) {
     return null;
   }
   return expression.callee.name;
@@ -3632,17 +3699,17 @@ function getMemberKind(descriptor) {
   return "data";
 }
 var getStaticMemberPropertyName = (node) => {
-  if (node.computed || node.property.type !== "Identifier") {
+  if (node.computed || node.property.type !== import_utils24.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return node.property.name;
 };
 var isCallUsage = (node) => {
   const parent = node.parent;
-  return parent.type === "CallExpression" && parent.callee === node;
+  return parent.type === import_utils24.AST_NODE_TYPES.CallExpression && parent.callee === node;
 };
 var nativeTypeInfoByName = buildNativeTypeInfoByName(nativeTypeDefinitions);
-var isNativeTypeName = (value) => (0, import_ts_extras37.setHas)(nativeTypeNameSet, value);
+var isNativeTypeName = (value) => (0, import_ts_extras37.setHas)(nativeTypeNameLookup, value);
 var rule51 = ruleCreator({
   create: (context) => ({
     MemberExpression: (node) => {
@@ -3745,20 +3812,116 @@ var deprecatedRule14 = withDeprecatedRuleLifecycle(rule53, {
 var no_value_tostring_default = deprecatedRule14;
 
 // dist/rules/no-vulnerable.js
+var import_utils25 = require("@typescript-eslint/utils");
+var import_node_module = require("node:module");
+var import_node_path5 = __toESM(require("node:path"), 1);
 var import_recheck = require("recheck");
 var import_ts_extras38 = require("ts-extras");
+var requireFromWorkingDirectory = (0, import_node_module.createRequire)(import_node_path5.default.join(process.cwd(), "package.json"));
+var isUnknownRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isModuleNotFoundError = (error) => {
+  if (!isUnknownRecord2(error)) {
+    return false;
+  }
+  return (0, import_ts_extras38.keyIn)(error, "code") && error["code"] === "MODULE_NOT_FOUND";
+};
+var createRequireFromPluginPackage = () => {
+  try {
+    return (0, import_node_module.createRequire)(requireFromWorkingDirectory.resolve("eslint-plugin-etc-misc/package.json"));
+  } catch (error) {
+    if (isModuleNotFoundError(error)) {
+      return requireFromWorkingDirectory;
+    }
+    throw error;
+  }
+};
+var requireFromPluginPackage = createRequireFromPluginPackage();
+var shouldOverrideRuntimePath = (currentPath) => !(0, import_ts_extras38.isDefined)(currentPath) || import_node_path5.default.basename(currentPath).toLowerCase() === "package.json";
+var resolvePackageSiblingFile = (packageJsonSpecifier, siblingFileName) => {
+  try {
+    const packageJsonPath = requireFromPluginPackage.resolve(packageJsonSpecifier);
+    return import_node_path5.default.join(import_node_path5.default.dirname(packageJsonPath), siblingFileName);
+  } catch (error) {
+    if (isModuleNotFoundError(error)) {
+      return null;
+    }
+    throw error;
+  }
+};
+var resolveRecheckJarPath = () => resolvePackageSiblingFile("recheck-jar/package.json", "recheck.jar");
+var resolveRecheckWindowsBinaryPath = () => {
+  if (process.platform !== "win32" || process.arch !== "x64") {
+    return null;
+  }
+  return resolvePackageSiblingFile("recheck-windows-x64/package.json", "recheck.exe");
+};
+var recheckJarPath = process.platform === "win32" ? resolveRecheckJarPath() : null;
+var recheckWindowsBinaryPath = process.platform === "win32" ? resolveRecheckWindowsBinaryPath() : null;
+var deleteRecheckEnvironmentValue = (key) => {
+  if (key === "RECHECK_BIN") {
+    delete process.env["RECHECK_BIN"];
+    return;
+  }
+  delete process.env["RECHECK_JAR"];
+};
+var getRecheckEnvironmentValue = (key) => key === "RECHECK_BIN" ? process.env["RECHECK_BIN"] : process.env["RECHECK_JAR"];
+var setRecheckEnvironmentValue = (key, value) => {
+  if (key === "RECHECK_BIN") {
+    process.env["RECHECK_BIN"] = value;
+    return;
+  }
+  process.env["RECHECK_JAR"] = value;
+};
+var getRecheckEnvironmentOverrides = () => {
+  if (process.platform !== "win32") {
+    return {};
+  }
+  const overrides = {};
+  if (recheckJarPath !== null && shouldOverrideRuntimePath(getRecheckEnvironmentValue("RECHECK_JAR"))) {
+    overrides.RECHECK_JAR = recheckJarPath;
+  }
+  if (recheckWindowsBinaryPath !== null && shouldOverrideRuntimePath(getRecheckEnvironmentValue("RECHECK_BIN"))) {
+    overrides.RECHECK_BIN = recheckWindowsBinaryPath;
+  }
+  return overrides;
+};
+var restoreEnvironmentValue = (key, value) => {
+  if (!(0, import_ts_extras38.isDefined)(value)) {
+    deleteRecheckEnvironmentValue(key);
+    return;
+  }
+  setRecheckEnvironmentValue(key, value);
+};
+var withRecheckEnvironmentOverrides = (callback) => {
+  const overrides = getRecheckEnvironmentOverrides();
+  const previousBin = getRecheckEnvironmentValue("RECHECK_BIN");
+  const previousJar = getRecheckEnvironmentValue("RECHECK_JAR");
+  if ((0, import_ts_extras38.isDefined)(overrides.RECHECK_BIN)) {
+    setRecheckEnvironmentValue("RECHECK_BIN", overrides.RECHECK_BIN);
+  }
+  if ((0, import_ts_extras38.isDefined)(overrides.RECHECK_JAR)) {
+    setRecheckEnvironmentValue("RECHECK_JAR", overrides.RECHECK_JAR);
+  }
+  try {
+    return callback();
+  } finally {
+    restoreEnvironmentValue("RECHECK_BIN", previousBin);
+    restoreEnvironmentValue("RECHECK_JAR", previousJar);
+  }
+};
+var runRecheck = (source, flags, parameters) => withRecheckEnvironmentOverrides(() => (0, import_recheck.checkSync)(source, flags, parameters));
 var getStaticStringValue = (node) => {
-  if (node.type === "Literal" && typeof node.value === "string") {
+  if (node.type === import_utils25.AST_NODE_TYPES.Literal && typeof node.value === "string") {
     return node.value;
   }
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis.length === 1) {
+  if (node.type === import_utils25.AST_NODE_TYPES.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 isNonSpreadArgument = (argument) => argument.type !== import_utils25.AST_NODE_TYPES.SpreadElement;
 var isRegExpConstructorCall = (node) => {
-  if (node.callee.type !== "Identifier" || node.callee.name !== "RegExp") {
+  if (node.callee.type !== import_utils25.AST_NODE_TYPES.Identifier || node.callee.name !== "RegExp") {
     return false;
   }
   if (node.arguments.length === 0 || node.arguments.length > 2) {
@@ -3776,7 +3939,7 @@ var isRegExpConstructorCall = (node) => {
   if (flagsArgument === void 0) {
     return true;
   }
-  if (flagsArgument.type === "SpreadElement") {
+  if (flagsArgument.type === import_utils25.AST_NODE_TYPES.SpreadElement) {
     return false;
   }
   return (0, import_ts_extras38.isDefined)(getStaticStringValue(flagsArgument));
@@ -3796,13 +3959,42 @@ var getDiagnosticsErrorMessage = (error) => {
   }
   return "No additional details provided.";
 };
+var getThrownErrorMessage = (error) => {
+  if (error instanceof Error && error.message.length > 0) {
+    return error.message;
+  }
+  if (typeof error === "string" && error.length > 0) {
+    return error;
+  }
+  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);
+      const diagnostics = (() => {
+        try {
+          return runRecheck(source, flags, recheckParameters);
+        } catch (error) {
+          if (ignoreErrors) {
+            return null;
+          }
+          context.report({
+            data: {
+              kind: "unexpected",
+              message: getThrownErrorMessage(error)
+            },
+            messageId: "checkerError",
+            node
+          });
+          return null;
+        }
+      })();
+      if (diagnostics === null) {
+        return;
+      }
       if (diagnostics.status === "safe") {
         return;
       }
@@ -3982,11 +4174,12 @@ var rule56 = ruleCreator({
 var object_format_default = rule56;
 
 // dist/rules/only-export-name.js
+var import_utils26 = require("@typescript-eslint/utils");
 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) => {
-      if (specifier.exported.type === "Identifier") {
+    return node.specifiers.flatMap((specifier) => {
+      if (specifier.exported.type === import_utils26.AST_NODE_TYPES.Identifier) {
         return [specifier.exported.name];
       }
       return [];
@@ -3996,13 +4189,13 @@ var getExportedNames = (node) => {
   if (declaration === null) {
     return [];
   }
-  if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
+  if (declaration.type === import_utils26.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils26.AST_NODE_TYPES.ClassDeclaration) {
     return declaration.id === null ? [] : [declaration.id.name];
   }
-  if (declaration.type === "VariableDeclaration") {
+  if (declaration.type === import_utils26.AST_NODE_TYPES.VariableDeclaration) {
     let names = [];
     for (const declarator of declaration.declarations) {
-      if (declarator.id.type === "Identifier") {
+      if (declarator.id.type === import_utils26.AST_NODE_TYPES.Identifier) {
         names = [...names, declarator.id.name];
       }
     }
@@ -4166,12 +4359,12 @@ 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_utils27 = require("@typescript-eslint/utils");
 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;
-var getTypeAliasDeclarationParent = (node) => node?.type === "TSTypeAliasDeclaration" ? node : void 0;
+var isExportedTypeAlias = (typeAliasDeclaration) => typeAliasDeclaration.parent.type === import_utils27.AST_NODE_TYPES.ExportNamedDeclaration && typeAliasDeclaration.parent.declaration === typeAliasDeclaration;
+var getTypeAliasDeclarationParent = (node) => node?.type === import_utils27.AST_NODE_TYPES.TSTypeAliasDeclaration ? node : void 0;
 var formatTypeParameters = (sourceCode, typeParameters) => typeParameters === void 0 ? "" : sourceCode.getText(typeParameters);
 var createTypeLiteralFixText = (sourceCode, typeAliasDeclaration, typeLiteralNode) => {
   const aliasTypeParameters = formatTypeParameters(sourceCode, typeAliasDeclaration.typeParameters);
@@ -4196,11 +4389,11 @@ var canSafelyConvertIntersection = (intersectionTypeNode, parserServices) => {
   let literals = [];
   let references = [];
   for (const intersectionMember of intersectionTypeNode.types) {
-    if (intersectionMember.type === "TSTypeLiteral") {
+    if (intersectionMember.type === import_utils27.AST_NODE_TYPES.TSTypeLiteral) {
       literals = [...literals, intersectionMember];
       continue;
     }
-    if (intersectionMember.type === "TSTypeReference") {
+    if (intersectionMember.type === import_utils27.AST_NODE_TYPES.TSTypeReference) {
       references = [...references, intersectionMember];
       continue;
     }
@@ -4239,7 +4432,7 @@ var rule61 = ruleCreator({
   create: (context) => {
     const [{ allowIntersection = true, allowLocal = false } = {}] = context.options;
     const sourceCode = context.sourceCode;
-    const parserServices = import_utils8.ESLintUtils.getParserServices(context, true);
+    const parserServices = import_utils27.ESLintUtils.getParserServices(context, true);
     const typedParserServices = hasFullTypeInformation(parserServices) ? parserServices : void 0;
     const shouldSkipForAllowLocal = (typeAliasDeclaration) => allowLocal && !isExportedTypeAlias(typeAliasDeclaration);
     return {
@@ -4449,6 +4642,7 @@ var rule64 = ruleCreator({
 var prefer_only_export_default = rule64;
 
 // dist/rules/require-jsdoc.js
+var import_utils28 = require("@typescript-eslint/utils");
 var import_ts_extras41 = require("ts-extras");
 var defaultKinds = [
   "arrow-function",
@@ -4460,7 +4654,7 @@ var defaultKinds = [
 var hasJSDocComment = (sourceCode, node) => {
   const comments = sourceCode.getCommentsBefore(node);
   const comment = (0, import_ts_extras41.arrayLast)(comments);
-  return comment?.type === "Block" && comment.value.startsWith("*");
+  return comment?.type === import_utils28.AST_TOKEN_TYPES.Block && comment.value.startsWith("*");
 };
 var reportMissingJSDoc = (context, node) => {
   if (hasJSDocComment(context.sourceCode, node)) {
@@ -4488,7 +4682,7 @@ var rule65 = ruleCreator({
         reportMissingJSDoc(context, node);
       },
       MethodDefinition: (node) => {
-        if (!(0, import_ts_extras41.setHas)(kinds, "method") || node.kind === "constructor" || node.key.type !== "Identifier") {
+        if (!(0, import_ts_extras41.setHas)(kinds, "method") || node.kind === "constructor" || node.key.type !== import_utils28.AST_NODE_TYPES.Identifier) {
           return;
         }
         reportMissingJSDoc(context, node);
@@ -4497,12 +4691,12 @@ var rule65 = ruleCreator({
         if (!(0, import_ts_extras41.setHas)(kinds, "type")) {
           return;
         }
-        if (node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration") {
+        if (node.type === import_utils28.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils28.AST_NODE_TYPES.TSTypeAliasDeclaration) {
           reportMissingJSDoc(context, node);
         }
       },
       VariableDeclarator: (node) => {
-        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") {
+        if (!(0, import_ts_extras41.setHas)(kinds, "arrow-function") || node.id.type !== import_utils28.AST_NODE_TYPES.Identifier || node.init?.type !== import_utils28.AST_NODE_TYPES.ArrowFunctionExpression || node.parent.kind !== "const") {
           return;
         }
         reportMissingJSDoc(context, node.parent);
@@ -4696,9 +4890,10 @@ var rule67 = ruleCreator({
 var restrict_identifier_characters_default = rule67;
 
 // dist/rules/sort-array.js
+var import_utils29 = require("@typescript-eslint/utils");
 var import_ts_extras43 = require("ts-extras");
 var getSortableValue = (element) => {
-  if (element.type === "Literal") {
+  if (element.type === import_utils29.AST_NODE_TYPES.Literal) {
     return String(element.value);
   }
   return void 0;
@@ -4794,12 +4989,13 @@ var rule69 = ruleCreator({
 var sort_call_signature_default = rule69;
 
 // dist/rules/sort-class-members.js
+var import_utils30 = require("@typescript-eslint/utils");
 var import_ts_extras44 = require("ts-extras");
 var memberName = (member) => {
-  if (member.key.type === "Identifier") {
+  if (member.key.type === import_utils30.AST_NODE_TYPES.Identifier) {
     return member.key.name;
   }
-  if (member.key.type === "Literal" && typeof member.key.value === "string") {
+  if (member.key.type === import_utils30.AST_NODE_TYPES.Literal && typeof member.key.value === "string") {
     return member.key.value;
   }
   return void 0;
@@ -4809,7 +5005,7 @@ var rule70 = ruleCreator({
     ClassBody: (node) => {
       let members = [];
       for (const member of node.body) {
-        if (member.type === "PropertyDefinition" || member.type === "MethodDefinition") {
+        if (member.type === import_utils30.AST_NODE_TYPES.PropertyDefinition || member.type === import_utils30.AST_NODE_TYPES.MethodDefinition) {
           members = [...members, member];
         }
       }
@@ -4906,8 +5102,9 @@ var rule71 = ruleCreator({
 var sort_construct_signature_default = rule71;
 
 // dist/rules/sort-export-specifiers.js
+var import_utils31 = require("@typescript-eslint/utils");
 var import_ts_extras45 = require("ts-extras");
-var toName = (specifier) => specifier.exported.type === "Identifier" ? specifier.exported.name : specifier.exported.value;
+var toName = (specifier) => specifier.exported.type === import_utils31.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
 var buildFix3 = (fixer, node, sourceCode, sorted) => {
   const startRange = (0, import_ts_extras45.arrayFirst)(node.specifiers)?.range ?? node.range;
   const endRange = (0, import_ts_extras45.arrayLast)(node.specifiers)?.range ?? node.range;
@@ -4918,9 +5115,7 @@ var rule72 = ruleCreator({
     ExportNamedDeclaration: (node) => {
       let exportSpecifiers = [];
       for (const specifier of node.specifiers) {
-        if (specifier.type === "ExportSpecifier") {
-          exportSpecifiers = [...exportSpecifiers, specifier];
-        }
+        exportSpecifiers = [...exportSpecifiers, specifier];
       }
       if (exportSpecifiers.length < 2) {
         return;
@@ -4959,12 +5154,13 @@ var rule72 = ruleCreator({
 var sort_export_specifiers_default = rule72;
 
 // dist/rules/sort-keys.js
+var import_utils32 = require("@typescript-eslint/utils");
 var import_ts_extras46 = require("ts-extras");
 var keyName = (property) => {
-  if (property.key.type === "Identifier") {
+  if (property.key.type === import_utils32.AST_NODE_TYPES.Identifier) {
     return property.key.name;
   }
-  if (property.key.type === "Literal" && typeof property.key.value === "string") {
+  if (property.key.type === import_utils32.AST_NODE_TYPES.Literal && typeof property.key.value === "string") {
     return property.key.value;
   }
   return void 0;
@@ -4983,7 +5179,7 @@ var rule73 = ruleCreator({
     ObjectExpression: (node) => {
       let properties = [];
       for (const property of node.properties) {
-        if (property.type === "Property" && property.kind === "init" && !property.computed) {
+        if (property.type === import_utils32.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed) {
           properties = [...properties, property];
         }
       }
@@ -5085,6 +5281,7 @@ var rule74 = ruleCreator({
 var sort_top_comments_default = rule74;
 
 // dist/rules/switch-case-spacing.js
+var import_utils33 = require("@typescript-eslint/utils");
 var import_ts_extras48 = require("ts-extras");
 var isValidCaseBody = (node) => {
   if (node.consequent.length === 0) {
@@ -5096,8 +5293,8 @@ var isValidCaseBody = (node) => {
     return true;
   }
   const startsOnFollowingLine = firstStatement.loc.start.line > node.loc.start.line;
-  const startsWithBlock = firstStatement.type === "BlockStatement";
-  const endsWithBreak = lastStatement.type === "BreakStatement" || startsWithBlock;
+  const startsWithBlock = firstStatement.type === import_utils33.AST_NODE_TYPES.BlockStatement;
+  const endsWithBreak = lastStatement.type === import_utils33.AST_NODE_TYPES.BreakStatement || startsWithBlock;
   return (startsOnFollowingLine || startsWithBlock) && endsWithBreak;
 };
 var rule75 = ruleCreator({
@@ -5157,9 +5354,9 @@ var hasExpectedBoundaryNewlines = (node) => {
   return first.startsWith("\n") && last.endsWith("\n");
 };
 var normalizeTemplate = (sourceText) => {
-  const lines = (0, import_ts_extras49.stringSplit)(sourceText.replaceAll(/\r\n?/gu, "\n"), "\n");
+  const lines = (0, import_ts_extras49.stringSplit)(sourceText.replaceAll(/\r\n?/gv, "\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 indents = contentLines.filter((line) => line.trim().length > 0).map((line) => /^\s*/v.exec(line)?.[0].length ?? 0);
   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) ?? "";
@@ -5209,22 +5406,22 @@ 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_utils34 = require("@typescript-eslint/utils");
 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));
 var couldBePromiseConstructorType = (type, program) => tsutils3.unionTypeParts(type).some((typeVariant) => (0, import_type_utils6.isBuiltinSymbolLike)(program, typeVariant, "PromiseConstructor"));
-var isPromiseIdentifier = (node) => node.type === "Identifier" && node.name === "Promise";
+var isPromiseIdentifier = (node) => node.type === import_utils34.AST_NODE_TYPES.Identifier && node.name === "Promise";
 var createWrapLiteralInErrorSuggestionFix = (sourceCode, node) => {
-  if (node.type !== "Literal") {
+  if (node.type !== import_utils34.AST_NODE_TYPES.Literal) {
     return void 0;
   }
   return (fixer) => fixer.replaceText(node, `new Error(${sourceCode.getText(node)})`);
 };
 var rule77 = ruleCreator({
   create: (context) => {
-    const parserServices = import_utils9.ESLintUtils.getParserServices(context);
+    const parserServices = import_utils34.ESLintUtils.getParserServices(context);
     const sourceCode = context.sourceCode;
     const { program } = parserServices;
     const reportIfNonErrorLike = (node, usage) => {
@@ -5257,7 +5454,7 @@ var rule77 = ruleCreator({
     return {
       "CallExpression[callee.type='MemberExpression'][callee.property.type='Identifier'][callee.property.name='reject']": (callExpression) => {
         const { callee } = callExpression;
-        if (callee.type !== "MemberExpression" || callee.object.type === "Super") {
+        if (callee.type !== import_utils34.AST_NODE_TYPES.MemberExpression || callee.object.type === import_utils34.AST_NODE_TYPES.Super) {
           return;
         }
         const objectType = (0, import_type_utils6.getConstrainedTypeAtLocation)(parserServices, callee.object);
@@ -5268,7 +5465,7 @@ var rule77 = ruleCreator({
       },
       "NewExpression[callee.type='Identifier'][callee.name='Promise'] > ArrowFunctionExpression, NewExpression[callee.type='Identifier'][callee.name='Promise'] > FunctionExpression": (callback) => {
         const rejectParameter = callback.params[1];
-        if (rejectParameter?.type !== "Identifier") {
+        if (rejectParameter?.type !== import_utils34.AST_NODE_TYPES.Identifier) {
           return;
         }
         const rejectVariable = (0, import_ts_extras50.arrayFirst)(context.sourceCode.getDeclaredVariables(callback).filter((declaredVariable) => declaredVariable.name === rejectParameter.name));
@@ -5278,16 +5475,13 @@ var rule77 = ruleCreator({
         for (const reference of rejectVariable.references) {
           const { identifier } = reference;
           const parent = identifier.parent;
-          if (parent?.type === "CallExpression" && parent.callee === identifier) {
+          if (parent.type === import_utils34.AST_NODE_TYPES.CallExpression && parent.callee === identifier) {
             checkRejectionCall(parent);
           }
         }
       },
       ThrowStatement: (throwStatement) => {
         const { argument } = throwStatement;
-        if (argument === null) {
-          return;
-        }
         reportIfNonErrorLike(argument, "Throwing");
       }
     };
@@ -5337,7 +5531,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_utils35 = require("@typescript-eslint/utils");
 var import_ts_extras51 = require("ts-extras");
 var arrayCallbackMethodNames = /* @__PURE__ */ new Set([
   "every",
@@ -5359,19 +5553,19 @@ var isArrayLikeType2 = (typeChecker, type) => {
 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 parserServices = import_utils35.ESLintUtils.getParserServices(context);
     const typeChecker = parserServices.program.getTypeChecker();
     return {
       [callbackSelector]: (callback) => {
         const parentNode = callback.parent;
-        if (parentNode?.type !== "CallExpression") {
+        if (parentNode.type !== import_utils35.AST_NODE_TYPES.CallExpression) {
           return;
         }
         if (!isFirstCallbackArgument(parentNode, callback)) {
           return;
         }
         const { callee } = parentNode;
-        if (callee.type !== "MemberExpression" || callee.object.type === "Super" || callee.property.type !== "Identifier" || !(0, import_ts_extras51.setHas)(arrayCallbackMethodNames, callee.property.name)) {
+        if (callee.type !== import_utils35.AST_NODE_TYPES.MemberExpression || callee.object.type === import_utils35.AST_NODE_TYPES.Super || callee.property.type !== import_utils35.AST_NODE_TYPES.Identifier || !(0, import_ts_extras51.setHas)(arrayCallbackMethodNames, callee.property.name)) {
           return;
         }
         const objectType = (0, import_type_utils7.getConstrainedTypeAtLocation)(parserServices, callee.object);
@@ -5407,6 +5601,7 @@ var rule79 = ruleCreator({
 var typescript_array_callback_return_type_default = rule79;
 
 // dist/rules/typescript-class-methods-use-this.js
+var import_utils36 = require("@typescript-eslint/utils");
 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) => {
@@ -5438,7 +5633,7 @@ var containsThisExpression = (root) => {
     if (node === void 0) {
       continue;
     }
-    if (node.type === "ThisExpression") {
+    if (node.type === import_utils36.AST_NODE_TYPES.ThisExpression) {
       return true;
     }
     stack = [...stack, ...collectNodeChildren(node)];
@@ -5447,7 +5642,7 @@ var containsThisExpression = (root) => {
 };
 var hasThisParameter = (node) => {
   const [firstParameter] = node.value.params;
-  return firstParameter?.type === "Identifier" && firstParameter.name === "this";
+  return firstParameter?.type === import_utils36.AST_NODE_TYPES.Identifier && firstParameter.name === "this";
 };
 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);
@@ -5609,6 +5804,7 @@ var deprecatedRule23 = withDeprecatedRuleLifecycle(rule83, {
 var typescript_exhaustive_switch_default = deprecatedRule23;
 
 // dist/rules/typescript-no-boolean-literal-type.js
+var import_utils37 = require("@typescript-eslint/utils");
 var import_ts_extras53 = require("ts-extras");
 var selector8 = (0, import_ts_extras53.arrayJoin)([
   "TSPropertySignature[optional=true] > TSTypeAnnotation > TSLiteralType > Literal[value=true]",
@@ -5617,7 +5813,7 @@ var selector8 = (0, import_ts_extras53.arrayJoin)([
 var rule84 = ruleCreator({
   create: (context) => ({
     [selector8]: (node) => {
-      if (node.type !== "Literal") {
+      if (node.type !== import_utils37.AST_NODE_TYPES.Literal) {
         return;
       }
       context.report({
@@ -5841,11 +6037,11 @@ 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 import_utils38 = require("@typescript-eslint/utils");
+var isTypeAliasNeverIdentifier = (node) => node.parent.type === import_utils38.AST_NODE_TYPES.TSTypeAliasDeclaration && node.parent.id === node && node.parent.typeAnnotation.type === import_utils38.AST_NODE_TYPES.TSNeverKeyword;
 var rule90 = ruleCreator({
   create: (context) => {
-    const parserServices = import_utils11.ESLintUtils.getParserServices(context);
+    const parserServices = import_utils38.ESLintUtils.getParserServices(context);
     return {
       Identifier: (node) => {
         if (isTypeAliasNeverIdentifier(node)) {
@@ -5884,11 +6080,12 @@ var rule90 = ruleCreator({
 var typescript_no_never_default = rule90;
 
 // dist/rules/typescript-no-redundant-undefined-const.js
+var import_utils39 = require("@typescript-eslint/utils");
 var import_ts_extras55 = require("ts-extras");
 var buildFixedTypeText = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
-    if (typeNode.type === "TSUndefinedKeyword") {
+    if (typeNode.type === import_utils39.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     nonUndefinedTypeTexts = [
@@ -5901,42 +6098,37 @@ var buildFixedTypeText = (sourceCode, unionType) => {
   }
   return (0, import_ts_extras55.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
-var getTypeAnnotationFromDeclarator = (declarator) => {
-  if (declarator.id.type === "Identifier" || declarator.id.type === "ArrayPattern" || declarator.id.type === "ObjectPattern") {
-    return declarator.id.typeAnnotation;
-  }
-  return void 0;
-};
+var getTypeAnnotationFromDeclarator = (declarator) => declarator.id.typeAnnotation;
 var unwrapExpression2 = (expression) => {
-  if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
+  if (expression.type === import_utils39.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils39.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils39.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils39.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression2(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression = (expression) => {
   const unwrappedExpression = unwrapExpression2(expression);
-  if (unwrappedExpression.type === "ArrayExpression") {
+  if (unwrappedExpression.type === import_utils39.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ArrowFunctionExpression") {
+  if (unwrappedExpression.type === import_utils39.AST_NODE_TYPES.ArrowFunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ClassExpression") {
+  if (unwrappedExpression.type === import_utils39.AST_NODE_TYPES.ClassExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "FunctionExpression") {
+  if (unwrappedExpression.type === import_utils39.AST_NODE_TYPES.FunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "Literal") {
+  if (unwrappedExpression.type === import_utils39.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (unwrappedExpression.type === "NewExpression") {
+  if (unwrappedExpression.type === import_utils39.AST_NODE_TYPES.NewExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ObjectExpression") {
+  if (unwrappedExpression.type === import_utils39.AST_NODE_TYPES.ObjectExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "TemplateLiteral") {
+  if (unwrappedExpression.type === import_utils39.AST_NODE_TYPES.TemplateLiteral) {
     return true;
   }
   return false;
@@ -5946,7 +6138,7 @@ var rule91 = ruleCreator({
     const sourceCode = context.sourceCode;
     return {
       'VariableDeclaration[kind="const"] > VariableDeclarator': (node) => {
-        if (node.type !== "VariableDeclarator") {
+        if (node.type !== import_utils39.AST_NODE_TYPES.VariableDeclarator) {
           return;
         }
         if (node.init === null) {
@@ -5959,7 +6151,7 @@ var rule91 = ruleCreator({
         if (typeAnnotation === void 0) {
           return;
         }
-        if (typeAnnotation.typeAnnotation.type !== "TSUnionType") {
+        if (typeAnnotation.typeAnnotation.type !== import_utils39.AST_NODE_TYPES.TSUnionType) {
           return;
         }
         const fixedTypeText = buildFixedTypeText(sourceCode, typeAnnotation.typeAnnotation);
@@ -6004,65 +6196,61 @@ var rule91 = ruleCreator({
 var typescript_no_redundant_undefined_const_default = rule91;
 
 // dist/rules/typescript-no-redundant-undefined-default-parameter.js
+var import_utils40 = require("@typescript-eslint/utils");
 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") {
+  if (node.type === import_utils40.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils40.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils40.AST_NODE_TYPES.FunctionExpression || node.type === import_utils40.AST_NODE_TYPES.TSCallSignatureDeclaration || node.type === import_utils40.AST_NODE_TYPES.TSConstructSignatureDeclaration || node.type === import_utils40.AST_NODE_TYPES.TSConstructorType || node.type === import_utils40.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils40.AST_NODE_TYPES.TSEmptyBodyFunctionExpression || node.type === import_utils40.AST_NODE_TYPES.TSFunctionType || node.type === import_utils40.AST_NODE_TYPES.TSMethodSignature) {
     return node.params;
   }
   return void 0;
 };
 var getAssignmentPatternFromPattern = (pattern) => {
-  if (pattern.type === "AssignmentPattern") {
+  if (pattern.type === import_utils40.AST_NODE_TYPES.AssignmentPattern) {
     return pattern;
   }
-  if (pattern.type === "RestElement") {
+  if (pattern.type === import_utils40.AST_NODE_TYPES.RestElement) {
     return void 0;
   }
   return void 0;
 };
 var getAssignmentPatternFromParameter = (parameter) => {
-  if (parameter.type === "TSParameterProperty") {
+  if (parameter.type === import_utils40.AST_NODE_TYPES.TSParameterProperty) {
     return getAssignmentPatternFromPattern(parameter.parameter);
   }
   return getAssignmentPatternFromPattern(parameter);
 };
-var getTypeAnnotationFromAssignmentPattern = (assignmentPattern) => {
-  if (assignmentPattern.left.type !== "ArrayPattern" && assignmentPattern.left.type !== "Identifier" && assignmentPattern.left.type !== "ObjectPattern") {
-    return void 0;
-  }
-  return assignmentPattern.left.typeAnnotation;
-};
+var getTypeAnnotationFromAssignmentPattern = (assignmentPattern) => assignmentPattern.left.typeAnnotation;
 var unwrapExpression3 = (expression) => {
-  if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
+  if (expression.type === import_utils40.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils40.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils40.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils40.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression3(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression2 = (expression) => {
   const unwrappedExpression = unwrapExpression3(expression);
-  if (unwrappedExpression.type === "ArrayExpression") {
+  if (unwrappedExpression.type === import_utils40.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ArrowFunctionExpression") {
+  if (unwrappedExpression.type === import_utils40.AST_NODE_TYPES.ArrowFunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ClassExpression") {
+  if (unwrappedExpression.type === import_utils40.AST_NODE_TYPES.ClassExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "FunctionExpression") {
+  if (unwrappedExpression.type === import_utils40.AST_NODE_TYPES.FunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "Literal") {
+  if (unwrappedExpression.type === import_utils40.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (unwrappedExpression.type === "NewExpression") {
+  if (unwrappedExpression.type === import_utils40.AST_NODE_TYPES.NewExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ObjectExpression") {
+  if (unwrappedExpression.type === import_utils40.AST_NODE_TYPES.ObjectExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "TemplateLiteral") {
+  if (unwrappedExpression.type === import_utils40.AST_NODE_TYPES.TemplateLiteral) {
     return true;
   }
   return false;
@@ -6070,7 +6258,7 @@ var isDefinitelyDefinedExpression2 = (expression) => {
 var buildFixedTypeText2 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
-    if (typeNode.type === "TSUndefinedKeyword") {
+    if (typeNode.type === import_utils40.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     nonUndefinedTypeTexts = [
@@ -6083,6 +6271,10 @@ var buildFixedTypeText2 = (sourceCode, unionType) => {
   }
   return (0, import_ts_extras56.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
+var createReplaceTypeFix = (targetNode, replacementText) => (fixer) => {
+  const [start, end] = targetNode.range;
+  return fixer.replaceTextRange([start, end], replacementText);
+};
 var rule92 = ruleCreator({
   create: (context) => {
     const sourceCode = context.sourceCode;
@@ -6104,14 +6296,14 @@ var rule92 = ruleCreator({
           if (typeAnnotation === void 0) {
             continue;
           }
-          if (typeAnnotation.typeAnnotation.type !== "TSUnionType") {
+          if (typeAnnotation.typeAnnotation.type !== import_utils40.AST_NODE_TYPES.TSUnionType) {
             continue;
           }
           const fixedTypeText = buildFixedTypeText2(sourceCode, typeAnnotation.typeAnnotation);
           if (!(0, import_ts_extras56.isDefined)(fixedTypeText)) {
             continue;
           }
-          const fix = (fixer) => fixer.replaceText(typeAnnotation.typeAnnotation, fixedTypeText);
+          const fix = createReplaceTypeFix(typeAnnotation.typeAnnotation, fixedTypeText);
           context.report({
             fix,
             messageId: "forbidden",
@@ -6150,11 +6342,12 @@ var rule92 = ruleCreator({
 var typescript_no_redundant_undefined_default_parameter_default = rule92;
 
 // dist/rules/typescript-no-redundant-undefined-let.js
+var import_utils41 = require("@typescript-eslint/utils");
 var import_ts_extras57 = require("ts-extras");
 var buildFixedTypeText3 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
-    if (typeNode.type === "TSUndefinedKeyword") {
+    if (typeNode.type === import_utils41.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     nonUndefinedTypeTexts = [
@@ -6168,35 +6361,35 @@ var buildFixedTypeText3 = (sourceCode, unionType) => {
   return (0, import_ts_extras57.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
 var unwrapExpression4 = (expression) => {
-  if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
+  if (expression.type === import_utils41.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils41.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils41.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils41.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression4(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression3 = (expression) => {
   const unwrappedExpression = unwrapExpression4(expression);
-  if (unwrappedExpression.type === "ArrayExpression") {
+  if (unwrappedExpression.type === import_utils41.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ArrowFunctionExpression") {
+  if (unwrappedExpression.type === import_utils41.AST_NODE_TYPES.ArrowFunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ClassExpression") {
+  if (unwrappedExpression.type === import_utils41.AST_NODE_TYPES.ClassExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "FunctionExpression") {
+  if (unwrappedExpression.type === import_utils41.AST_NODE_TYPES.FunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "Literal") {
+  if (unwrappedExpression.type === import_utils41.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (unwrappedExpression.type === "NewExpression") {
+  if (unwrappedExpression.type === import_utils41.AST_NODE_TYPES.NewExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ObjectExpression") {
+  if (unwrappedExpression.type === import_utils41.AST_NODE_TYPES.ObjectExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "TemplateLiteral") {
+  if (unwrappedExpression.type === import_utils41.AST_NODE_TYPES.TemplateLiteral) {
     return true;
   }
   return false;
@@ -6224,14 +6417,14 @@ var rule93 = ruleCreator({
           return;
         }
         const id = node.id;
-        if (id.type !== "Identifier") {
+        if (id.type !== import_utils41.AST_NODE_TYPES.Identifier) {
           return;
         }
         const typeAnnotation = id.typeAnnotation;
         if (typeAnnotation === void 0) {
           return;
         }
-        if (typeAnnotation.typeAnnotation.type !== "TSUnionType") {
+        if (typeAnnotation.typeAnnotation.type !== import_utils41.AST_NODE_TYPES.TSUnionType) {
           return;
         }
         const fixedTypeText = buildFixedTypeText3(sourceCode, typeAnnotation.typeAnnotation);
@@ -6276,6 +6469,7 @@ var rule93 = ruleCreator({
 var typescript_no_redundant_undefined_let_default = rule93;
 
 // dist/rules/typescript-no-redundant-undefined-optional.js
+var import_utils42 = require("@typescript-eslint/utils");
 var import_ts_extras58 = require("ts-extras");
 var selector14 = (0, import_ts_extras58.arrayJoin)([
   "Identifier[optional=true] > TSTypeAnnotation > TSUnionType",
@@ -6285,7 +6479,7 @@ var selector14 = (0, import_ts_extras58.arrayJoin)([
 var buildFixedTypeText4 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
-    if (typeNode.type === "TSUndefinedKeyword") {
+    if (typeNode.type === import_utils42.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     nonUndefinedTypeTexts = [
@@ -6303,7 +6497,7 @@ var rule94 = ruleCreator({
     const sourceCode = context.sourceCode;
     return {
       [selector14]: (node) => {
-        if (node.type !== "TSUnionType") {
+        if (node.type !== import_utils42.AST_NODE_TYPES.TSUnionType) {
           return;
         }
         const fixedTypeText = buildFixedTypeText4(sourceCode, node);
@@ -6348,11 +6542,12 @@ var rule94 = ruleCreator({
 var typescript_no_redundant_undefined_optional_default = rule94;
 
 // dist/rules/typescript-no-redundant-undefined-promise-return-type.js
+var import_utils43 = require("@typescript-eslint/utils");
 var import_ts_extras59 = require("ts-extras");
 var buildFixedTypeText5 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
-    if (typeNode.type === "TSUndefinedKeyword") {
+    if (typeNode.type === import_utils43.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     nonUndefinedTypeTexts = [
@@ -6366,52 +6561,52 @@ var buildFixedTypeText5 = (sourceCode, unionType) => {
   return (0, import_ts_extras59.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
 var unwrapExpression5 = (expression) => {
-  if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
+  if (expression.type === import_utils43.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils43.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils43.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils43.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression5(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression4 = (expression) => {
   const unwrappedExpression = unwrapExpression5(expression);
-  if (unwrappedExpression.type === "ArrayExpression") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ArrowFunctionExpression") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.ArrowFunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ClassExpression") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.ClassExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ConditionalExpression") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.ConditionalExpression) {
     return isDefinitelyDefinedExpression4(unwrappedExpression.consequent) && isDefinitelyDefinedExpression4(unwrappedExpression.alternate);
   }
-  if (unwrappedExpression.type === "FunctionExpression") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.FunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "Literal") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (unwrappedExpression.type === "LogicalExpression" && unwrappedExpression.operator === "??") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.LogicalExpression && unwrappedExpression.operator === "??") {
     return isDefinitelyDefinedExpression4(unwrappedExpression.right);
   }
-  if (unwrappedExpression.type === "NewExpression") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.NewExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ObjectExpression") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.ObjectExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "SequenceExpression") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.SequenceExpression) {
     const lastExpression = (0, import_ts_extras59.arrayAt)(unwrappedExpression.expressions, -1);
     return lastExpression !== void 0 && isDefinitelyDefinedExpression4(lastExpression);
   }
-  if (unwrappedExpression.type === "TemplateLiteral") {
+  if (unwrappedExpression.type === import_utils43.AST_NODE_TYPES.TemplateLiteral) {
     return true;
   }
   return false;
 };
 var hasDefinitelyDefinedReturnValue = (node) => {
   const body = node.body;
-  if (body.type !== "BlockStatement") {
+  if (body.type !== import_utils43.AST_NODE_TYPES.BlockStatement) {
     return isDefinitelyDefinedExpression4(body);
   }
   if (body.body.length !== 1) {
@@ -6421,7 +6616,7 @@ var hasDefinitelyDefinedReturnValue = (node) => {
   if (statement === void 0) {
     return false;
   }
-  if (statement.type !== "ReturnStatement") {
+  if (statement.type !== import_utils43.AST_NODE_TYPES.ReturnStatement) {
     return false;
   }
   if (statement.argument === null) {
@@ -6431,10 +6626,10 @@ var hasDefinitelyDefinedReturnValue = (node) => {
 };
 var getPromiseValueUnionType = (returnType) => {
   const annotation = returnType.typeAnnotation;
-  if (annotation.type !== "TSTypeReference") {
+  if (annotation.type !== import_utils43.AST_NODE_TYPES.TSTypeReference) {
     return void 0;
   }
-  if (annotation.typeName.type !== "Identifier") {
+  if (annotation.typeName.type !== import_utils43.AST_NODE_TYPES.Identifier) {
     return void 0;
   }
   if (annotation.typeName.name !== "Promise") {
@@ -6448,7 +6643,7 @@ var getPromiseValueUnionType = (returnType) => {
   if (promiseValueType === void 0) {
     return void 0;
   }
-  if (promiseValueType.type !== "TSUnionType") {
+  if (promiseValueType.type !== import_utils43.AST_NODE_TYPES.TSUnionType) {
     return void 0;
   }
   return promiseValueType;
@@ -6458,7 +6653,7 @@ var rule95 = ruleCreator({
     const sourceCode = context.sourceCode;
     return {
       ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression)[async=true]": (node) => {
-        if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionDeclaration" && node.type !== "FunctionExpression") {
+        if (node.type !== import_utils43.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils43.AST_NODE_TYPES.FunctionDeclaration && node.type !== import_utils43.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         const returnType = node.returnType;
@@ -6514,11 +6709,12 @@ var rule95 = ruleCreator({
 var typescript_no_redundant_undefined_promise_return_type_default = rule95;
 
 // dist/rules/typescript-no-redundant-undefined-readonly-property.js
+var import_utils44 = require("@typescript-eslint/utils");
 var import_ts_extras60 = require("ts-extras");
 var buildFixedTypeText6 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
-    if (typeNode.type === "TSUndefinedKeyword") {
+    if (typeNode.type === import_utils44.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     nonUndefinedTypeTexts = [
@@ -6532,35 +6728,35 @@ var buildFixedTypeText6 = (sourceCode, unionType) => {
   return (0, import_ts_extras60.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
 var unwrapExpression6 = (expression) => {
-  if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
+  if (expression.type === import_utils44.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils44.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils44.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils44.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression6(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression5 = (expression) => {
   const unwrappedExpression = unwrapExpression6(expression);
-  if (unwrappedExpression.type === "ArrayExpression") {
+  if (unwrappedExpression.type === import_utils44.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ArrowFunctionExpression") {
+  if (unwrappedExpression.type === import_utils44.AST_NODE_TYPES.ArrowFunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ClassExpression") {
+  if (unwrappedExpression.type === import_utils44.AST_NODE_TYPES.ClassExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "FunctionExpression") {
+  if (unwrappedExpression.type === import_utils44.AST_NODE_TYPES.FunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "Literal") {
+  if (unwrappedExpression.type === import_utils44.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (unwrappedExpression.type === "NewExpression") {
+  if (unwrappedExpression.type === import_utils44.AST_NODE_TYPES.NewExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ObjectExpression") {
+  if (unwrappedExpression.type === import_utils44.AST_NODE_TYPES.ObjectExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "TemplateLiteral") {
+  if (unwrappedExpression.type === import_utils44.AST_NODE_TYPES.TemplateLiteral) {
     return true;
   }
   return false;
@@ -6570,7 +6766,7 @@ var rule96 = ruleCreator({
     const sourceCode = context.sourceCode;
     return {
       "PropertyDefinition[readonly=true][optional!=true]": (node) => {
-        if (node.type !== "PropertyDefinition") {
+        if (node.type !== import_utils44.AST_NODE_TYPES.PropertyDefinition) {
           return;
         }
         if (node.declare) {
@@ -6586,7 +6782,7 @@ var rule96 = ruleCreator({
         if (typeAnnotation === void 0) {
           return;
         }
-        if (typeAnnotation.typeAnnotation.type !== "TSUnionType") {
+        if (typeAnnotation.typeAnnotation.type !== import_utils44.AST_NODE_TYPES.TSUnionType) {
           return;
         }
         const fixedTypeText = buildFixedTypeText6(sourceCode, typeAnnotation.typeAnnotation);
@@ -6631,11 +6827,12 @@ var rule96 = ruleCreator({
 var typescript_no_redundant_undefined_readonly_property_default = rule96;
 
 // dist/rules/typescript-no-redundant-undefined-return-type.js
+var import_utils45 = require("@typescript-eslint/utils");
 var import_ts_extras61 = require("ts-extras");
 var buildFixedTypeText7 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
-    if (typeNode.type === "TSUndefinedKeyword") {
+    if (typeNode.type === import_utils45.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     nonUndefinedTypeTexts = [
@@ -6649,52 +6846,52 @@ var buildFixedTypeText7 = (sourceCode, unionType) => {
   return (0, import_ts_extras61.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
 var unwrapExpression7 = (expression) => {
-  if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
+  if (expression.type === import_utils45.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils45.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils45.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils45.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression7(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression6 = (expression) => {
   const unwrappedExpression = unwrapExpression7(expression);
-  if (unwrappedExpression.type === "ArrayExpression") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ArrowFunctionExpression") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.ArrowFunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ClassExpression") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.ClassExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ConditionalExpression") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.ConditionalExpression) {
     return isDefinitelyDefinedExpression6(unwrappedExpression.consequent) && isDefinitelyDefinedExpression6(unwrappedExpression.alternate);
   }
-  if (unwrappedExpression.type === "FunctionExpression") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.FunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "Literal") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (unwrappedExpression.type === "LogicalExpression" && unwrappedExpression.operator === "??") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.LogicalExpression && unwrappedExpression.operator === "??") {
     return isDefinitelyDefinedExpression6(unwrappedExpression.right);
   }
-  if (unwrappedExpression.type === "NewExpression") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.NewExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ObjectExpression") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.ObjectExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "SequenceExpression") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.SequenceExpression) {
     const lastExpression = (0, import_ts_extras61.arrayAt)(unwrappedExpression.expressions, -1);
     return lastExpression !== void 0 && isDefinitelyDefinedExpression6(lastExpression);
   }
-  if (unwrappedExpression.type === "TemplateLiteral") {
+  if (unwrappedExpression.type === import_utils45.AST_NODE_TYPES.TemplateLiteral) {
     return true;
   }
   return false;
 };
 var hasDefinitelyDefinedReturnValue2 = (node) => {
   const body = node.body;
-  if (body.type !== "BlockStatement") {
+  if (body.type !== import_utils45.AST_NODE_TYPES.BlockStatement) {
     return isDefinitelyDefinedExpression6(body);
   }
   if (body.body.length !== 1) {
@@ -6704,7 +6901,7 @@ var hasDefinitelyDefinedReturnValue2 = (node) => {
   if (statement === void 0) {
     return false;
   }
-  if (statement.type !== "ReturnStatement") {
+  if (statement.type !== import_utils45.AST_NODE_TYPES.ReturnStatement) {
     return false;
   }
   if (statement.argument === null) {
@@ -6717,14 +6914,14 @@ var rule97 = ruleCreator({
     const sourceCode = context.sourceCode;
     return {
       ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression)": (node) => {
-        if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionDeclaration" && node.type !== "FunctionExpression") {
+        if (node.type !== import_utils45.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils45.AST_NODE_TYPES.FunctionDeclaration && node.type !== import_utils45.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         const returnType = node.returnType;
         if (returnType === void 0) {
           return;
         }
-        if (returnType.typeAnnotation.type !== "TSUnionType") {
+        if (returnType.typeAnnotation.type !== import_utils45.AST_NODE_TYPES.TSUnionType) {
           return;
         }
         if (!hasDefinitelyDefinedReturnValue2(node)) {
@@ -6772,11 +6969,12 @@ var rule97 = ruleCreator({
 var typescript_no_redundant_undefined_return_type_default = rule97;
 
 // dist/rules/typescript-no-redundant-undefined-var.js
+var import_utils46 = require("@typescript-eslint/utils");
 var import_ts_extras62 = require("ts-extras");
 var buildFixedTypeText8 = (sourceCode, unionType) => {
   let nonUndefinedTypeTexts = [];
   for (const typeNode of unionType.types) {
-    if (typeNode.type === "TSUndefinedKeyword") {
+    if (typeNode.type === import_utils46.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     nonUndefinedTypeTexts = [
@@ -6790,35 +6988,35 @@ var buildFixedTypeText8 = (sourceCode, unionType) => {
   return (0, import_ts_extras62.arrayJoin)(nonUndefinedTypeTexts, " | ");
 };
 var unwrapExpression8 = (expression) => {
-  if (expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSNonNullExpression" || expression.type === "TSTypeAssertion") {
+  if (expression.type === import_utils46.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils46.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils46.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils46.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression8(expression.expression);
   }
   return expression;
 };
 var isDefinitelyDefinedExpression7 = (expression) => {
   const unwrappedExpression = unwrapExpression8(expression);
-  if (unwrappedExpression.type === "ArrayExpression") {
+  if (unwrappedExpression.type === import_utils46.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ArrowFunctionExpression") {
+  if (unwrappedExpression.type === import_utils46.AST_NODE_TYPES.ArrowFunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ClassExpression") {
+  if (unwrappedExpression.type === import_utils46.AST_NODE_TYPES.ClassExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "FunctionExpression") {
+  if (unwrappedExpression.type === import_utils46.AST_NODE_TYPES.FunctionExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "Literal") {
+  if (unwrappedExpression.type === import_utils46.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (unwrappedExpression.type === "NewExpression") {
+  if (unwrappedExpression.type === import_utils46.AST_NODE_TYPES.NewExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "ObjectExpression") {
+  if (unwrappedExpression.type === import_utils46.AST_NODE_TYPES.ObjectExpression) {
     return true;
   }
-  if (unwrappedExpression.type === "TemplateLiteral") {
+  if (unwrappedExpression.type === import_utils46.AST_NODE_TYPES.TemplateLiteral) {
     return true;
   }
   return false;
@@ -6846,14 +7044,14 @@ var rule98 = ruleCreator({
           return;
         }
         const id = node.id;
-        if (id.type !== "Identifier") {
+        if (id.type !== import_utils46.AST_NODE_TYPES.Identifier) {
           return;
         }
         const typeAnnotation = id.typeAnnotation;
         if (typeAnnotation === void 0) {
           return;
         }
-        if (typeAnnotation.typeAnnotation.type !== "TSUnionType") {
+        if (typeAnnotation.typeAnnotation.type !== import_utils46.AST_NODE_TYPES.TSUnionType) {
           return;
         }
         const fixedTypeText = buildFixedTypeText8(sourceCode, typeAnnotation.typeAnnotation);
@@ -6898,21 +7096,25 @@ var rule98 = ruleCreator({
 var typescript_no_redundant_undefined_var_default = rule98;
 
 // dist/rules/typescript-no-restricted-syntax.js
+var import_ts_extras63 = require("ts-extras");
+var noRestrictedSyntaxRule = no_restricted_syntax_default;
+var baseDocs = noRestrictedSyntaxRule.meta.docs;
+(0, import_ts_extras63.assertDefined)(baseDocs);
 var typescriptNoRestrictedSyntaxRule = {
-  ...no_restricted_syntax_default,
+  ...noRestrictedSyntaxRule,
   meta: {
     deprecated: true,
-    ...no_restricted_syntax_default.meta,
+    ...noRestrictedSyntaxRule.meta,
     docs: {
+      ...baseDocs,
       deprecated: true,
       frozen: true,
       recommended: false,
-      ...no_restricted_syntax_default.meta.docs,
       url: "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/typescript-no-restricted-syntax"
     }
   }
 };
-var deprecatedRule26 = withDeprecatedRuleLifecycle(typescriptNoRestrictedSyntaxRule, {
+var rule99 = withDeprecatedRuleLifecycle(typescriptNoRestrictedSyntaxRule, {
   message: "Deprecated in favor of @typescript-eslint/no-restricted-syntax.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -6928,15 +7130,15 @@ var deprecatedRule26 = withDeprecatedRuleLifecycle(typescriptNoRestrictedSyntaxR
   ],
   ruleId: "typescript/no-restricted-syntax"
 });
-var typescript_no_restricted_syntax_default = deprecatedRule26;
+var typescript_no_restricted_syntax_default = rule99;
 
 // dist/rules/typescript-no-unsafe-object-assign.js
 var import_type_utils9 = require("@typescript-eslint/type-utils");
-var import_utils12 = require("@typescript-eslint/utils");
+var import_utils47 = require("@typescript-eslint/utils");
 var tsutils4 = __toESM(require("tsutils"), 1);
-var rule99 = ruleCreator({
+var rule100 = ruleCreator({
   create: (context) => {
-    const parserServices = import_utils12.ESLintUtils.getParserServices(context);
+    const parserServices = import_utils47.ESLintUtils.getParserServices(context);
     const checker = parserServices.program.getTypeChecker();
     const hasReadonlyProperty = (type) => type.getProperties().some((property) => tsutils4.isPropertyReadonlyInType(type, property.getEscapedName(), checker));
     return {
@@ -6975,24 +7177,28 @@ var rule99 = ruleCreator({
   },
   name: "typescript/no-unsafe-object-assign"
 });
-var typescript_no_unsafe_object_assign_default = rule99;
+var typescript_no_unsafe_object_assign_default = rule100;
 
 // dist/rules/typescript-no-unsafe-object-assignment.js
-var rule100 = {
-  ...typescript_no_unsafe_object_assign_default,
+var import_ts_extras64 = require("ts-extras");
+var coreNoUnsafeObjectAssignRule = typescript_no_unsafe_object_assign_default;
+var baseDocs2 = coreNoUnsafeObjectAssignRule.meta.docs;
+(0, import_ts_extras64.assertDefined)(baseDocs2);
+var typescriptNoUnsafeObjectAssignmentRule = {
+  ...coreNoUnsafeObjectAssignRule,
   meta: {
     deprecated: false,
-    ...typescript_no_unsafe_object_assign_default.meta,
+    ...coreNoUnsafeObjectAssignRule.meta,
     docs: {
+      ...baseDocs2,
       deprecated: false,
       frozen: false,
       recommended: false,
-      ...typescript_no_unsafe_object_assign_default.meta.docs,
       url: "https://nick2bad4u.github.io/eslint-plugin-etc-misc/docs/rules/typescript-no-unsafe-object-assignment"
     }
   }
 };
-var typescript_no_unsafe_object_assignment_default = rule100;
+var typescript_no_unsafe_object_assignment_default = typescriptNoUnsafeObjectAssignmentRule;
 
 // 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])`;
@@ -7058,8 +7264,8 @@ 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_extras63 = require("ts-extras");
+var import_utils48 = require("@typescript-eslint/utils");
+var import_ts_extras65 = require("ts-extras");
 var tsutils5 = __toESM(require("tsutils"), 1);
 var import_typescript = __toESM(require("typescript"), 1);
 var isEnumLikeOrUndefinedType = (checker, type) => {
@@ -7077,10 +7283,10 @@ var isEnumLikeOrUndefinedType = (checker, type) => {
   }
   return hasEnumLike;
 };
-var isStringLiteral = (node) => node.type === "Literal" && typeof node.value === "string";
+var isStringLiteral = (node) => node.type === import_utils48.AST_NODE_TYPES.Literal && typeof node.value === "string";
 var rule103 = ruleCreator({
   create: (context) => {
-    const parserServices = import_utils13.ESLintUtils.getParserServices(context);
+    const parserServices = import_utils48.ESLintUtils.getParserServices(context);
     const checker = parserServices.program.getTypeChecker();
     return {
       BinaryExpression: (node) => {
@@ -7088,16 +7294,11 @@ var rule103 = ruleCreator({
         if (!isEqualityOperator) {
           return;
         }
-        let literalNode = null;
-        if (isStringLiteral(node.left)) {
-          literalNode = node.left;
-        } else if (isStringLiteral(node.right)) {
-          literalNode = node.right;
-        }
-        const expressionNode = literalNode === node.left ? node.right : node.left;
+        const literalNode = isStringLiteral(node.left) ? node.left : isStringLiteral(node.right) ? node.right : null;
         if (literalNode === null) {
           return;
         }
+        const expressionNode = literalNode === node.left ? node.right : node.left;
         const expressionType = (0, import_type_utils10.getConstrainedTypeAtLocation)(parserServices, expressionNode);
         if (!isEnumLikeOrUndefinedType(checker, expressionType)) {
           return;
@@ -7113,16 +7314,16 @@ var rule103 = ruleCreator({
         }
         let functionNode = null;
         for (const ancestor of context.sourceCode.getAncestors(node)) {
-          if (ancestor.type === "ArrowFunctionExpression" || ancestor.type === "FunctionDeclaration" || ancestor.type === "FunctionExpression") {
+          if (ancestor.type === import_utils48.AST_NODE_TYPES.ArrowFunctionExpression || ancestor.type === import_utils48.AST_NODE_TYPES.FunctionDeclaration || ancestor.type === import_utils48.AST_NODE_TYPES.FunctionExpression) {
             functionNode = ancestor;
           }
         }
         if (functionNode === null) {
           return;
         }
-        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)) {
+        const signature = (0, import_ts_extras65.arrayFirst)((0, import_type_utils10.getConstrainedTypeAtLocation)(parserServices, functionNode).getCallSignatures());
+        const returnType = (0, import_ts_extras65.isDefined)(signature) ? checker.getReturnTypeOfSignature(signature) : void 0;
+        if (!(0, import_ts_extras65.isDefined)(returnType)) {
           return;
         }
         if (!isEnumLikeOrUndefinedType(checker, returnType)) {
@@ -7134,12 +7335,12 @@ var rule103 = ruleCreator({
         });
       },
       TSTypeAliasDeclaration: (node) => {
-        if (node.typeAnnotation.type !== "TSUnionType") {
+        if (node.typeAnnotation.type !== import_utils48.AST_NODE_TYPES.TSUnionType) {
           return;
         }
         let literalCount = 0;
         for (const typeNode of node.typeAnnotation.types) {
-          if (typeNode.type === "TSLiteralType" && typeNode.literal.type === "Literal" && typeof typeNode.literal.value === "string") {
+          if (typeNode.type === import_utils48.AST_NODE_TYPES.TSLiteralType && typeNode.literal.type === import_utils48.AST_NODE_TYPES.Literal && typeof typeNode.literal.value === "string") {
             literalCount += 1;
           }
         }
@@ -7176,11 +7377,12 @@ var rule103 = ruleCreator({
 var typescript_prefer_enum_default = rule103;
 
 // dist/rules/typescript-prefer-named-tuple-members.js
+var import_utils49 = require("@typescript-eslint/utils");
 var isUnnamedTupleElement = (tupleElement) => {
-  if (tupleElement.type === "TSNamedTupleMember") {
+  if (tupleElement.type === import_utils49.AST_NODE_TYPES.TSNamedTupleMember) {
     return false;
   }
-  if (tupleElement.type === "TSRestType" && tupleElement.typeAnnotation.type === "TSNamedTupleMember") {
+  if (tupleElement.type === import_utils49.AST_NODE_TYPES.TSRestType && tupleElement.typeAnnotation.type === import_utils49.AST_NODE_TYPES.TSNamedTupleMember) {
     return false;
   }
   return true;
@@ -7199,11 +7401,11 @@ var generateUniqueTupleMemberName = (preferredName, usedNames) => {
   return generatedName;
 };
 var getTupleMemberReplacementText = (tupleElement, memberName2, sourceCode) => {
-  if (tupleElement.type === "TSOptionalType") {
+  if (tupleElement.type === import_utils49.AST_NODE_TYPES.TSOptionalType) {
     return `${memberName2}?: ${sourceCode.getText(tupleElement.typeAnnotation)}`;
   }
-  if (tupleElement.type === "TSRestType") {
-    if (tupleElement.typeAnnotation.type === "TSNamedTupleMember") {
+  if (tupleElement.type === import_utils49.AST_NODE_TYPES.TSRestType) {
+    if (tupleElement.typeAnnotation.type === import_utils49.AST_NODE_TYPES.TSNamedTupleMember) {
       return sourceCode.getText(tupleElement);
     }
     return `...${memberName2}: ${sourceCode.getText(tupleElement.typeAnnotation)}`;
@@ -7220,10 +7422,7 @@ var rule104 = ruleCreator({
           return;
         }
         const usedNames = new Set(node.elementTypes.flatMap((tupleElement) => {
-          if (tupleElement.type !== "TSNamedTupleMember") {
-            return [];
-          }
-          if (tupleElement.label.type !== "Identifier") {
+          if (tupleElement.type !== import_utils49.AST_NODE_TYPES.TSNamedTupleMember) {
             return [];
           }
           return [tupleElement.label.name];
@@ -7279,23 +7478,24 @@ var rule104 = ruleCreator({
 var typescript_prefer_named_tuple_members_default = rule104;
 
 // dist/rules/typescript-prefer-readonly-array-parameter.js
+var import_utils50 = require("@typescript-eslint/utils");
 var functionLikeNodeSelector2 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
 var getParametersFromFunctionLikeNode2 = (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") {
+  if (node.type === import_utils50.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils50.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils50.AST_NODE_TYPES.FunctionExpression || node.type === import_utils50.AST_NODE_TYPES.TSCallSignatureDeclaration || node.type === import_utils50.AST_NODE_TYPES.TSConstructSignatureDeclaration || node.type === import_utils50.AST_NODE_TYPES.TSConstructorType || node.type === import_utils50.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils50.AST_NODE_TYPES.TSEmptyBodyFunctionExpression || node.type === import_utils50.AST_NODE_TYPES.TSFunctionType || node.type === import_utils50.AST_NODE_TYPES.TSMethodSignature) {
     return node.params;
   }
   return void 0;
 };
 var getTypeAnnotationFromPattern = (pattern) => {
-  if (pattern.type === "AssignmentPattern") {
+  if (pattern.type === import_utils50.AST_NODE_TYPES.AssignmentPattern) {
     return getTypeAnnotationFromPattern(pattern.left);
   }
-  if (pattern.type === "RestElement") {
+  if (pattern.type === import_utils50.AST_NODE_TYPES.RestElement) {
     if (pattern.typeAnnotation !== void 0) {
       return pattern.typeAnnotation;
     }
     const argument = pattern.argument;
-    if (argument.type !== "ArrayPattern" && argument.type !== "Identifier" && argument.type !== "ObjectPattern") {
+    if (argument.type !== import_utils50.AST_NODE_TYPES.ArrayPattern && argument.type !== import_utils50.AST_NODE_TYPES.Identifier && argument.type !== import_utils50.AST_NODE_TYPES.ObjectPattern) {
       return void 0;
     }
     return argument.typeAnnotation;
@@ -7303,20 +7503,20 @@ var getTypeAnnotationFromPattern = (pattern) => {
   return pattern.typeAnnotation;
 };
 var getTypeAnnotationFromParameter = (parameter) => {
-  if (parameter.type === "TSParameterProperty") {
+  if (parameter.type === import_utils50.AST_NODE_TYPES.TSParameterProperty) {
     return getTypeAnnotationFromPattern(parameter.parameter);
   }
   return getTypeAnnotationFromPattern(parameter);
 };
-var isArrayTypeReference = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Array";
+var isArrayTypeReference = (node) => node.typeName.type === import_utils50.AST_NODE_TYPES.Identifier && node.typeName.name === "Array";
 var collectMutableArrayLikeTypeNodes = (typeNode) => {
-  if (typeNode.type === "TSArrayType" || typeNode.type === "TSTupleType") {
+  if (typeNode.type === import_utils50.AST_NODE_TYPES.TSArrayType || typeNode.type === import_utils50.AST_NODE_TYPES.TSTupleType) {
     return [typeNode];
   }
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils50.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils50.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableArrayLikeTypeNodes(subTypeNode));
   }
-  if (typeNode.type === "TSTypeReference") {
+  if (typeNode.type === import_utils50.AST_NODE_TYPES.TSTypeReference) {
     if (!isArrayTypeReference(typeNode)) {
       return [];
     }
@@ -7325,7 +7525,7 @@ var collectMutableArrayLikeTypeNodes = (typeNode) => {
   return [];
 };
 var buildReadonlyArrayLikeFix = (node, sourceCode) => {
-  if (node.type === "Identifier") {
+  if (node.type === import_utils50.AST_NODE_TYPES.Identifier) {
     return (fixer) => fixer.replaceText(node, "ReadonlyArray");
   }
   return (fixer) => fixer.replaceText(node, `readonly ${sourceCode.getText(node)}`);
@@ -7386,8 +7586,9 @@ var rule105 = ruleCreator({
 var typescript_prefer_readonly_array_parameter_default = rule105;
 
 // dist/rules/typescript-prefer-readonly-array.js
-var import_ts_extras64 = require("ts-extras");
-var selector17 = (0, import_ts_extras64.arrayJoin)([
+var import_utils51 = require("@typescript-eslint/utils");
+var import_ts_extras66 = require("ts-extras");
+var selector17 = (0, import_ts_extras66.arrayJoin)([
   ":not(TSTypeOperator[operator='readonly']) > :matches(TSArrayType, TSTupleType)",
   "TSTypeReference > Identifier[name='Array']"
 ], ", ");
@@ -7396,10 +7597,10 @@ var rule106 = ruleCreator({
     const sourceCode = context.sourceCode;
     return {
       [selector17]: (node) => {
-        if (node.type !== "Identifier" && node.type !== "TSArrayType" && node.type !== "TSTupleType") {
+        if (node.type !== import_utils51.AST_NODE_TYPES.Identifier && node.type !== import_utils51.AST_NODE_TYPES.TSArrayType && node.type !== import_utils51.AST_NODE_TYPES.TSTupleType) {
           return;
         }
-        const fix = node.type === "Identifier" ? (fixer) => fixer.replaceText(node, "ReadonlyArray") : (fixer) => fixer.replaceText(node, `readonly ${sourceCode.getText(node)}`);
+        const fix = node.type === import_utils51.AST_NODE_TYPES.Identifier ? (fixer) => fixer.replaceText(node, "ReadonlyArray") : (fixer) => fixer.replaceText(node, `readonly ${sourceCode.getText(node)}`);
         context.report({
           fix,
           messageId: "forbidden",
@@ -7430,11 +7631,12 @@ var rule106 = ruleCreator({
 var typescript_prefer_readonly_array_default = rule106;
 
 // dist/rules/typescript-prefer-readonly-index-signature.js
+var import_utils52 = require("@typescript-eslint/utils");
 var selector18 = "TSIndexSignature[readonly!=true]";
 var rule107 = ruleCreator({
   create: (context) => ({
     [selector18]: (node) => {
-      if (node.type !== "TSIndexSignature" || node.readonly) {
+      if (node.type !== import_utils52.AST_NODE_TYPES.TSIndexSignature || node.readonly) {
         return;
       }
       context.report({
@@ -7466,11 +7668,12 @@ var rule107 = ruleCreator({
 var typescript_prefer_readonly_index_signature_default = rule107;
 
 // dist/rules/typescript-prefer-readonly-map.js
+var import_utils53 = require("@typescript-eslint/utils");
 var selector19 = "TSTypeReference > Identifier[name='Map']";
 var rule108 = ruleCreator({
   create: (context) => ({
     [selector19]: (node) => {
-      if (node.type !== "Identifier") {
+      if (node.type !== import_utils53.AST_NODE_TYPES.Identifier) {
         return;
       }
       context.report({
@@ -7502,20 +7705,21 @@ var rule108 = ruleCreator({
 var typescript_prefer_readonly_map_default = rule108;
 
 // dist/rules/typescript-prefer-readonly-property.js
-var import_ts_extras65 = require("ts-extras");
+var import_utils54 = require("@typescript-eslint/utils");
+var import_ts_extras67 = require("ts-extras");
 var selector20 = ":matches(PropertyDefinition, TSPropertySignature)[readonly!=true]";
 var rule109 = ruleCreator({
   create: (context) => ({
     [selector20]: (node) => {
-      if (node.type !== "PropertyDefinition" && node.type !== "TSPropertySignature") {
+      if (node.type !== import_utils54.AST_NODE_TYPES.PropertyDefinition && node.type !== import_utils54.AST_NODE_TYPES.TSPropertySignature) {
         return;
       }
       const keyNode = node.key;
-      const fix = keyNode.type === "Identifier" || keyNode.type === "PrivateIdentifier" || keyNode.type === "Literal" ? (fixer) => fixer.insertTextBefore(keyNode, "readonly ") : void 0;
+      const fix = keyNode.type === import_utils54.AST_NODE_TYPES.Identifier || keyNode.type === import_utils54.AST_NODE_TYPES.PrivateIdentifier || keyNode.type === import_utils54.AST_NODE_TYPES.Literal ? (fixer) => fixer.insertTextBefore(keyNode, "readonly ") : void 0;
       context.report({
         messageId: "forbidden",
         node,
-        ...(0, import_ts_extras65.isDefined)(fix) ? {
+        ...(0, import_ts_extras67.isDefined)(fix) ? {
           fix,
           suggest: [
             {
@@ -7550,23 +7754,24 @@ var rule109 = ruleCreator({
 var typescript_prefer_readonly_property_default = rule109;
 
 // dist/rules/typescript-prefer-readonly-record.js
+var import_utils55 = require("@typescript-eslint/utils");
 var selector21 = "TSTypeReference > Identifier[name='Record']";
 var isReadonlyWrappedRecord = (typeReference) => {
   const parent = typeReference.parent;
-  if (parent?.type !== "TSTypeParameterInstantiation") {
+  if (parent.type !== import_utils55.AST_NODE_TYPES.TSTypeParameterInstantiation) {
     return false;
   }
   const maybeReadonlyTypeReference = parent.parent;
-  return maybeReadonlyTypeReference?.type === "TSTypeReference" && maybeReadonlyTypeReference.typeName.type === "Identifier" && maybeReadonlyTypeReference.typeName.name === "Readonly";
+  return maybeReadonlyTypeReference.type === import_utils55.AST_NODE_TYPES.TSTypeReference && maybeReadonlyTypeReference.typeName.type === import_utils55.AST_NODE_TYPES.Identifier && maybeReadonlyTypeReference.typeName.name === "Readonly";
 };
 var rule110 = ruleCreator({
   create: (context) => ({
     [selector21]: (node) => {
-      if (node.type !== "Identifier") {
+      if (node.type !== import_utils55.AST_NODE_TYPES.Identifier) {
         return;
       }
       const typeReference = node.parent;
-      if (typeReference?.type !== "TSTypeReference" || typeReference.typeName.type !== "Identifier" || typeReference.typeName.name !== "Record" || isReadonlyWrappedRecord(typeReference)) {
+      if (typeReference.type !== import_utils55.AST_NODE_TYPES.TSTypeReference || typeReference.typeName.type !== import_utils55.AST_NODE_TYPES.Identifier || typeReference.typeName.name !== "Record" || isReadonlyWrappedRecord(typeReference)) {
         return;
       }
       context.report({
@@ -7601,11 +7806,12 @@ var rule110 = ruleCreator({
 var typescript_prefer_readonly_record_default = rule110;
 
 // dist/rules/typescript-prefer-readonly-set.js
+var import_utils56 = require("@typescript-eslint/utils");
 var selector22 = "TSTypeReference > Identifier[name='Set']";
 var rule111 = ruleCreator({
   create: (context) => ({
     [selector22]: (node) => {
-      if (node.type !== "Identifier") {
+      if (node.type !== import_utils56.AST_NODE_TYPES.Identifier) {
         return;
       }
       context.report({
@@ -7637,20 +7843,21 @@ var rule111 = ruleCreator({
 var typescript_prefer_readonly_set_default = rule111;
 
 // dist/rules/typescript-require-prop-type-annotation.js
-var import_ts_extras66 = require("ts-extras");
+var import_utils57 = require("@typescript-eslint/utils");
+var import_ts_extras68 = require("ts-extras");
 var selector23 = "PropertyDefinition[typeAnnotation=undefined][value=null]";
 var rule112 = ruleCreator({
   create: (context) => ({
     [selector23]: (node) => {
-      if (node.type !== "PropertyDefinition") {
+      if (node.type !== import_utils57.AST_NODE_TYPES.PropertyDefinition) {
         return;
       }
-      const canProvideSafeSuggestion = !node.computed && node.key.type === "Identifier" && !node.optional && !node.definite;
+      const canProvideSafeSuggestion = !node.computed && node.key.type === import_utils57.AST_NODE_TYPES.Identifier && !node.optional && !node.definite;
       const fix = canProvideSafeSuggestion ? (fixer) => fixer.insertTextAfter(node.key, ": unknown") : void 0;
       context.report({
         messageId: "forbidden",
         node,
-        ...(0, import_ts_extras66.isDefined)(fix) ? {
+        ...(0, import_ts_extras68.isDefined)(fix) ? {
           fix,
           suggest: [
             {
@@ -7685,15 +7892,16 @@ var rule112 = ruleCreator({
 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";
+var import_utils58 = require("@typescript-eslint/utils");
+var isArrayTypeReference2 = (node) => node.typeName.type === import_utils58.AST_NODE_TYPES.Identifier && node.typeName.name === "Array";
 var collectMutableArrayLikeTypeNodes2 = (typeNode) => {
-  if (typeNode.type === "TSArrayType" || typeNode.type === "TSTupleType") {
+  if (typeNode.type === import_utils58.AST_NODE_TYPES.TSArrayType || typeNode.type === import_utils58.AST_NODE_TYPES.TSTupleType) {
     return [typeNode];
   }
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils58.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils58.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableArrayLikeTypeNodes2(subTypeNode));
   }
-  if (typeNode.type === "TSTypeReference") {
+  if (typeNode.type === import_utils58.AST_NODE_TYPES.TSTypeReference) {
     if (!isArrayTypeReference2(typeNode)) {
       return [];
     }
@@ -7702,21 +7910,18 @@ var collectMutableArrayLikeTypeNodes2 = (typeNode) => {
   return [];
 };
 var buildReadonlyArrayLikeFix2 = (node, sourceCode) => {
-  if (node.type === "Identifier") {
+  if (node.type === import_utils58.AST_NODE_TYPES.Identifier) {
     return (fixer) => fixer.replaceText(node, "ReadonlyArray");
   }
   return (fixer) => fixer.replaceText(node, `readonly ${sourceCode.getText(node)}`);
 };
 var isTopLevelPropertySignature = (node) => {
   const parent = node.parent;
-  if (parent?.type === "TSInterfaceBody") {
+  if (parent.type === import_utils58.AST_NODE_TYPES.TSInterfaceBody) {
     return true;
   }
-  if (parent?.type !== "TSTypeLiteral") {
-    return false;
-  }
   const maybeTypeAliasDeclaration = parent.parent;
-  return maybeTypeAliasDeclaration?.type === "TSTypeAliasDeclaration";
+  return maybeTypeAliasDeclaration.type === import_utils58.AST_NODE_TYPES.TSTypeAliasDeclaration;
 };
 var rule113 = ruleCreator({
   create: (context) => {
@@ -7771,22 +7976,23 @@ var rule113 = ruleCreator({
 var typescript_require_readonly_array_property_type_default = rule113;
 
 // dist/rules/typescript-require-readonly-array-return-type.js
+var import_utils59 = require("@typescript-eslint/utils");
 var functionLikeNodeSelector3 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
 var getReturnTypeAnnotationFromFunctionLikeNode = (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") {
+  if (node.type === import_utils59.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils59.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils59.AST_NODE_TYPES.FunctionExpression || node.type === import_utils59.AST_NODE_TYPES.TSCallSignatureDeclaration || node.type === import_utils59.AST_NODE_TYPES.TSConstructSignatureDeclaration || node.type === import_utils59.AST_NODE_TYPES.TSConstructorType || node.type === import_utils59.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils59.AST_NODE_TYPES.TSEmptyBodyFunctionExpression || node.type === import_utils59.AST_NODE_TYPES.TSFunctionType || node.type === import_utils59.AST_NODE_TYPES.TSMethodSignature) {
     return node.returnType;
   }
   return void 0;
 };
-var isArrayTypeReference3 = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Array";
+var isArrayTypeReference3 = (node) => node.typeName.type === import_utils59.AST_NODE_TYPES.Identifier && node.typeName.name === "Array";
 var collectMutableArrayLikeTypeNodes3 = (typeNode) => {
-  if (typeNode.type === "TSArrayType" || typeNode.type === "TSTupleType") {
+  if (typeNode.type === import_utils59.AST_NODE_TYPES.TSArrayType || typeNode.type === import_utils59.AST_NODE_TYPES.TSTupleType) {
     return [typeNode];
   }
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils59.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils59.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableArrayLikeTypeNodes3(subTypeNode));
   }
-  if (typeNode.type === "TSTypeReference") {
+  if (typeNode.type === import_utils59.AST_NODE_TYPES.TSTypeReference) {
     if (!isArrayTypeReference3(typeNode)) {
       return [];
     }
@@ -7795,7 +8001,7 @@ var collectMutableArrayLikeTypeNodes3 = (typeNode) => {
   return [];
 };
 var buildReadonlyArrayLikeFix3 = (node, sourceCode) => {
-  if (node.type === "Identifier") {
+  if (node.type === import_utils59.AST_NODE_TYPES.Identifier) {
     return (fixer) => fixer.replaceText(node, "ReadonlyArray");
   }
   return (fixer) => fixer.replaceText(node, `readonly ${sourceCode.getText(node)}`);
@@ -7850,15 +8056,16 @@ var rule114 = ruleCreator({
 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";
+var import_utils60 = require("@typescript-eslint/utils");
+var isArrayTypeReference4 = (node) => node.typeName.type === import_utils60.AST_NODE_TYPES.Identifier && node.typeName.name === "Array";
 var collectMutableArrayLikeTypeNodes4 = (typeNode) => {
-  if (typeNode.type === "TSArrayType" || typeNode.type === "TSTupleType") {
+  if (typeNode.type === import_utils60.AST_NODE_TYPES.TSArrayType || typeNode.type === import_utils60.AST_NODE_TYPES.TSTupleType) {
     return [typeNode];
   }
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils60.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils60.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableArrayLikeTypeNodes4(subTypeNode));
   }
-  if (typeNode.type === "TSTypeReference") {
+  if (typeNode.type === import_utils60.AST_NODE_TYPES.TSTypeReference) {
     if (!isArrayTypeReference4(typeNode)) {
       return [];
     }
@@ -7867,7 +8074,7 @@ var collectMutableArrayLikeTypeNodes4 = (typeNode) => {
   return [];
 };
 var buildReadonlyArrayLikeFix4 = (node, sourceCode) => {
-  if (node.type === "Identifier") {
+  if (node.type === import_utils60.AST_NODE_TYPES.Identifier) {
     return (fixer) => fixer.replaceText(node, "ReadonlyArray");
   }
   return (fixer) => fixer.replaceText(node, `readonly ${sourceCode.getText(node)}`);
@@ -7918,23 +8125,24 @@ var rule115 = ruleCreator({
 var typescript_require_readonly_array_type_alias_default = rule115;
 
 // dist/rules/typescript-require-readonly-map-parameter-type.js
+var import_utils61 = require("@typescript-eslint/utils");
 var functionLikeNodeSelector4 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
 var getParametersFromFunctionLikeNode3 = (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") {
+  if (node.type === import_utils61.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils61.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils61.AST_NODE_TYPES.FunctionExpression || node.type === import_utils61.AST_NODE_TYPES.TSCallSignatureDeclaration || node.type === import_utils61.AST_NODE_TYPES.TSConstructSignatureDeclaration || node.type === import_utils61.AST_NODE_TYPES.TSConstructorType || node.type === import_utils61.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils61.AST_NODE_TYPES.TSEmptyBodyFunctionExpression || node.type === import_utils61.AST_NODE_TYPES.TSFunctionType || node.type === import_utils61.AST_NODE_TYPES.TSMethodSignature) {
     return node.params;
   }
   return void 0;
 };
 var getTypeAnnotationFromPattern2 = (pattern) => {
-  if (pattern.type === "AssignmentPattern") {
+  if (pattern.type === import_utils61.AST_NODE_TYPES.AssignmentPattern) {
     return getTypeAnnotationFromPattern2(pattern.left);
   }
-  if (pattern.type === "RestElement") {
+  if (pattern.type === import_utils61.AST_NODE_TYPES.RestElement) {
     if (pattern.typeAnnotation !== void 0) {
       return pattern.typeAnnotation;
     }
     const argument = pattern.argument;
-    if (argument.type !== "ArrayPattern" && argument.type !== "Identifier" && argument.type !== "ObjectPattern") {
+    if (argument.type !== import_utils61.AST_NODE_TYPES.ArrayPattern && argument.type !== import_utils61.AST_NODE_TYPES.Identifier && argument.type !== import_utils61.AST_NODE_TYPES.ObjectPattern) {
       return void 0;
     }
     return argument.typeAnnotation;
@@ -7942,17 +8150,17 @@ var getTypeAnnotationFromPattern2 = (pattern) => {
   return pattern.typeAnnotation;
 };
 var getTypeAnnotationFromParameter2 = (parameter) => {
-  if (parameter.type === "TSParameterProperty") {
+  if (parameter.type === import_utils61.AST_NODE_TYPES.TSParameterProperty) {
     return getTypeAnnotationFromPattern2(parameter.parameter);
   }
   return getTypeAnnotationFromPattern2(parameter);
 };
-var isMapTypeReference = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Map";
+var isMapTypeReference = (node) => node.typeName.type === import_utils61.AST_NODE_TYPES.Identifier && node.typeName.name === "Map";
 var collectMutableMapTypeNodes = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils61.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils61.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableMapTypeNodes(subTypeNode));
   }
-  if (typeNode.type !== "TSTypeReference" || !isMapTypeReference(typeNode)) {
+  if (typeNode.type !== import_utils61.AST_NODE_TYPES.TSTypeReference || !isMapTypeReference(typeNode)) {
     return [];
   }
   return [typeNode.typeName];
@@ -8011,12 +8219,13 @@ var rule116 = ruleCreator({
 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";
+var import_utils62 = require("@typescript-eslint/utils");
+var isMapTypeReference2 = (node) => node.typeName.type === import_utils62.AST_NODE_TYPES.Identifier && node.typeName.name === "Map";
 var collectMutableMapTypeNodes2 = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils62.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils62.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableMapTypeNodes2(subTypeNode));
   }
-  if (typeNode.type !== "TSTypeReference" || !isMapTypeReference2(typeNode)) {
+  if (typeNode.type !== import_utils62.AST_NODE_TYPES.TSTypeReference || !isMapTypeReference2(typeNode)) {
     return [];
   }
   return [typeNode.typeName];
@@ -8024,14 +8233,11 @@ var collectMutableMapTypeNodes2 = (typeNode) => {
 var buildReadonlyMapFix2 = (node) => (fixer) => fixer.replaceText(node, "ReadonlyMap");
 var isTopLevelPropertySignature2 = (node) => {
   const parent = node.parent;
-  if (parent?.type === "TSInterfaceBody") {
+  if (parent.type === import_utils62.AST_NODE_TYPES.TSInterfaceBody) {
     return true;
   }
-  if (parent?.type !== "TSTypeLiteral") {
-    return false;
-  }
   const maybeTypeAliasDeclaration = parent.parent;
-  return maybeTypeAliasDeclaration?.type === "TSTypeAliasDeclaration";
+  return maybeTypeAliasDeclaration.type === import_utils62.AST_NODE_TYPES.TSTypeAliasDeclaration;
 };
 var rule117 = ruleCreator({
   create: (context) => ({
@@ -8083,19 +8289,20 @@ var rule117 = ruleCreator({
 var typescript_require_readonly_map_property_type_default = rule117;
 
 // dist/rules/typescript-require-readonly-map-return-type.js
+var import_utils63 = require("@typescript-eslint/utils");
 var functionLikeNodeSelector5 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
 var getReturnTypeAnnotationFromFunctionLikeNode2 = (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") {
+  if (node.type === import_utils63.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils63.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils63.AST_NODE_TYPES.FunctionExpression || node.type === import_utils63.AST_NODE_TYPES.TSCallSignatureDeclaration || node.type === import_utils63.AST_NODE_TYPES.TSConstructSignatureDeclaration || node.type === import_utils63.AST_NODE_TYPES.TSConstructorType || node.type === import_utils63.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils63.AST_NODE_TYPES.TSEmptyBodyFunctionExpression || node.type === import_utils63.AST_NODE_TYPES.TSFunctionType || node.type === import_utils63.AST_NODE_TYPES.TSMethodSignature) {
     return node.returnType;
   }
   return void 0;
 };
-var isMapTypeReference3 = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Map";
+var isMapTypeReference3 = (node) => node.typeName.type === import_utils63.AST_NODE_TYPES.Identifier && node.typeName.name === "Map";
 var collectMutableMapTypeNodes3 = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils63.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils63.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableMapTypeNodes3(subTypeNode));
   }
-  if (typeNode.type !== "TSTypeReference" || !isMapTypeReference3(typeNode)) {
+  if (typeNode.type !== import_utils63.AST_NODE_TYPES.TSTypeReference || !isMapTypeReference3(typeNode)) {
     return [];
   }
   return [typeNode.typeName];
@@ -8148,12 +8355,13 @@ var rule118 = ruleCreator({
 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";
+var import_utils64 = require("@typescript-eslint/utils");
+var isMapTypeReference4 = (node) => node.typeName.type === import_utils64.AST_NODE_TYPES.Identifier && node.typeName.name === "Map";
 var collectMutableMapTypeNodes4 = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils64.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils64.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableMapTypeNodes4(subTypeNode));
   }
-  if (typeNode.type !== "TSTypeReference" || !isMapTypeReference4(typeNode)) {
+  if (typeNode.type !== import_utils64.AST_NODE_TYPES.TSTypeReference || !isMapTypeReference4(typeNode)) {
     return [];
   }
   return [typeNode.typeName];
@@ -8202,23 +8410,24 @@ var rule119 = ruleCreator({
 var typescript_require_readonly_map_type_alias_default = rule119;
 
 // dist/rules/typescript-require-readonly-record-parameter-type.js
+var import_utils65 = require("@typescript-eslint/utils");
 var functionLikeNodeSelector6 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
 var getParametersFromFunctionLikeNode4 = (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") {
+  if (node.type === import_utils65.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils65.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils65.AST_NODE_TYPES.FunctionExpression || node.type === import_utils65.AST_NODE_TYPES.TSCallSignatureDeclaration || node.type === import_utils65.AST_NODE_TYPES.TSConstructSignatureDeclaration || node.type === import_utils65.AST_NODE_TYPES.TSConstructorType || node.type === import_utils65.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils65.AST_NODE_TYPES.TSEmptyBodyFunctionExpression || node.type === import_utils65.AST_NODE_TYPES.TSFunctionType || node.type === import_utils65.AST_NODE_TYPES.TSMethodSignature) {
     return node.params;
   }
   return void 0;
 };
 var getTypeAnnotationFromPattern3 = (pattern) => {
-  if (pattern.type === "AssignmentPattern") {
+  if (pattern.type === import_utils65.AST_NODE_TYPES.AssignmentPattern) {
     return getTypeAnnotationFromPattern3(pattern.left);
   }
-  if (pattern.type === "RestElement") {
+  if (pattern.type === import_utils65.AST_NODE_TYPES.RestElement) {
     if (pattern.typeAnnotation !== void 0) {
       return pattern.typeAnnotation;
     }
     const argument = pattern.argument;
-    if (argument.type !== "ArrayPattern" && argument.type !== "Identifier" && argument.type !== "ObjectPattern") {
+    if (argument.type !== import_utils65.AST_NODE_TYPES.ArrayPattern && argument.type !== import_utils65.AST_NODE_TYPES.Identifier && argument.type !== import_utils65.AST_NODE_TYPES.ObjectPattern) {
       return void 0;
     }
     return argument.typeAnnotation;
@@ -8226,22 +8435,22 @@ var getTypeAnnotationFromPattern3 = (pattern) => {
   return pattern.typeAnnotation;
 };
 var getTypeAnnotationFromParameter3 = (parameter) => {
-  if (parameter.type === "TSParameterProperty") {
+  if (parameter.type === import_utils65.AST_NODE_TYPES.TSParameterProperty) {
     return getTypeAnnotationFromPattern3(parameter.parameter);
   }
   return getTypeAnnotationFromPattern3(parameter);
 };
-var isRecordTypeReference = (typeNode) => typeNode.type === "TSTypeReference" && typeNode.typeName.type === "Identifier" && typeNode.typeName.name === "Record";
+var isRecordTypeReference = (typeNode) => typeNode.type === import_utils65.AST_NODE_TYPES.TSTypeReference && typeNode.typeName.type === import_utils65.AST_NODE_TYPES.Identifier && typeNode.typeName.name === "Record";
 var isReadonlyWrappedRecord2 = (typeReference) => {
   const maybeTypeParameterInstantiation = typeReference.parent;
-  if (maybeTypeParameterInstantiation?.type !== "TSTypeParameterInstantiation") {
+  if (maybeTypeParameterInstantiation.type !== import_utils65.AST_NODE_TYPES.TSTypeParameterInstantiation) {
     return false;
   }
   const maybeReadonlyTypeReference = maybeTypeParameterInstantiation.parent;
-  return maybeReadonlyTypeReference?.type === "TSTypeReference" && maybeReadonlyTypeReference.typeName.type === "Identifier" && maybeReadonlyTypeReference.typeName.name === "Readonly";
+  return maybeReadonlyTypeReference.type === import_utils65.AST_NODE_TYPES.TSTypeReference && maybeReadonlyTypeReference.typeName.type === import_utils65.AST_NODE_TYPES.Identifier && maybeReadonlyTypeReference.typeName.name === "Readonly";
 };
 var collectMutableRecordTypeNodes = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils65.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils65.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableRecordTypeNodes(subTypeNode));
   }
   if (!isRecordTypeReference(typeNode) || isReadonlyWrappedRecord2(typeNode)) {
@@ -8306,17 +8515,18 @@ var rule120 = ruleCreator({
 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";
+var import_utils66 = require("@typescript-eslint/utils");
+var isRecordTypeReference2 = (typeNode) => typeNode.type === import_utils66.AST_NODE_TYPES.TSTypeReference && typeNode.typeName.type === import_utils66.AST_NODE_TYPES.Identifier && typeNode.typeName.name === "Record";
 var isReadonlyWrappedRecord3 = (typeReference) => {
   const maybeTypeParameterInstantiation = typeReference.parent;
-  if (maybeTypeParameterInstantiation?.type !== "TSTypeParameterInstantiation") {
+  if (maybeTypeParameterInstantiation.type !== import_utils66.AST_NODE_TYPES.TSTypeParameterInstantiation) {
     return false;
   }
   const maybeReadonlyTypeReference = maybeTypeParameterInstantiation.parent;
-  return maybeReadonlyTypeReference?.type === "TSTypeReference" && maybeReadonlyTypeReference.typeName.type === "Identifier" && maybeReadonlyTypeReference.typeName.name === "Readonly";
+  return maybeReadonlyTypeReference.type === import_utils66.AST_NODE_TYPES.TSTypeReference && maybeReadonlyTypeReference.typeName.type === import_utils66.AST_NODE_TYPES.Identifier && maybeReadonlyTypeReference.typeName.name === "Readonly";
 };
 var collectMutableRecordTypeNodes2 = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils66.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils66.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableRecordTypeNodes2(subTypeNode));
   }
   if (!isRecordTypeReference2(typeNode) || isReadonlyWrappedRecord3(typeNode)) {
@@ -8330,14 +8540,11 @@ var buildReadonlyRecordFix2 = (node) => (fixer) => [
 ];
 var isTopLevelPropertySignature3 = (node) => {
   const parent = node.parent;
-  if (parent?.type === "TSInterfaceBody") {
+  if (parent.type === import_utils66.AST_NODE_TYPES.TSInterfaceBody) {
     return true;
   }
-  if (parent?.type !== "TSTypeLiteral") {
-    return false;
-  }
   const maybeTypeAliasDeclaration = parent.parent;
-  return maybeTypeAliasDeclaration?.type === "TSTypeAliasDeclaration";
+  return maybeTypeAliasDeclaration.type === import_utils66.AST_NODE_TYPES.TSTypeAliasDeclaration;
 };
 var rule121 = ruleCreator({
   create: (context) => ({
@@ -8389,24 +8596,25 @@ var rule121 = ruleCreator({
 var typescript_require_readonly_record_property_type_default = rule121;
 
 // dist/rules/typescript-require-readonly-record-return-type.js
+var import_utils67 = require("@typescript-eslint/utils");
 var functionLikeNodeSelector7 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
 var getReturnTypeAnnotationFromFunctionLikeNode3 = (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") {
+  if (node.type === import_utils67.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils67.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils67.AST_NODE_TYPES.FunctionExpression || node.type === import_utils67.AST_NODE_TYPES.TSCallSignatureDeclaration || node.type === import_utils67.AST_NODE_TYPES.TSConstructSignatureDeclaration || node.type === import_utils67.AST_NODE_TYPES.TSConstructorType || node.type === import_utils67.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils67.AST_NODE_TYPES.TSEmptyBodyFunctionExpression || node.type === import_utils67.AST_NODE_TYPES.TSFunctionType || node.type === import_utils67.AST_NODE_TYPES.TSMethodSignature) {
     return node.returnType;
   }
   return void 0;
 };
-var isRecordTypeReference3 = (typeNode) => typeNode.type === "TSTypeReference" && typeNode.typeName.type === "Identifier" && typeNode.typeName.name === "Record";
+var isRecordTypeReference3 = (typeNode) => typeNode.type === import_utils67.AST_NODE_TYPES.TSTypeReference && typeNode.typeName.type === import_utils67.AST_NODE_TYPES.Identifier && typeNode.typeName.name === "Record";
 var isReadonlyWrappedRecord4 = (typeReference) => {
   const maybeTypeParameterInstantiation = typeReference.parent;
-  if (maybeTypeParameterInstantiation?.type !== "TSTypeParameterInstantiation") {
+  if (maybeTypeParameterInstantiation.type !== import_utils67.AST_NODE_TYPES.TSTypeParameterInstantiation) {
     return false;
   }
   const maybeReadonlyTypeReference = maybeTypeParameterInstantiation.parent;
-  return maybeReadonlyTypeReference?.type === "TSTypeReference" && maybeReadonlyTypeReference.typeName.type === "Identifier" && maybeReadonlyTypeReference.typeName.name === "Readonly";
+  return maybeReadonlyTypeReference.type === import_utils67.AST_NODE_TYPES.TSTypeReference && maybeReadonlyTypeReference.typeName.type === import_utils67.AST_NODE_TYPES.Identifier && maybeReadonlyTypeReference.typeName.name === "Readonly";
 };
 var collectMutableRecordTypeNodes3 = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils67.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils67.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableRecordTypeNodes3(subTypeNode));
   }
   if (!isRecordTypeReference3(typeNode) || isReadonlyWrappedRecord4(typeNode)) {
@@ -8465,17 +8673,18 @@ var rule122 = ruleCreator({
 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";
+var import_utils68 = require("@typescript-eslint/utils");
+var isRecordTypeReference4 = (typeNode) => typeNode.type === import_utils68.AST_NODE_TYPES.TSTypeReference && typeNode.typeName.type === import_utils68.AST_NODE_TYPES.Identifier && typeNode.typeName.name === "Record";
 var isReadonlyWrappedRecord5 = (typeReference) => {
   const maybeTypeParameterInstantiation = typeReference.parent;
-  if (maybeTypeParameterInstantiation?.type !== "TSTypeParameterInstantiation") {
+  if (maybeTypeParameterInstantiation.type !== import_utils68.AST_NODE_TYPES.TSTypeParameterInstantiation) {
     return false;
   }
   const maybeReadonlyTypeReference = maybeTypeParameterInstantiation.parent;
-  return maybeReadonlyTypeReference?.type === "TSTypeReference" && maybeReadonlyTypeReference.typeName.type === "Identifier" && maybeReadonlyTypeReference.typeName.name === "Readonly";
+  return maybeReadonlyTypeReference.type === import_utils68.AST_NODE_TYPES.TSTypeReference && maybeReadonlyTypeReference.typeName.type === import_utils68.AST_NODE_TYPES.Identifier && maybeReadonlyTypeReference.typeName.name === "Readonly";
 };
 var collectMutableRecordTypeNodes4 = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils68.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils68.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableRecordTypeNodes4(subTypeNode));
   }
   if (!isRecordTypeReference4(typeNode) || isReadonlyWrappedRecord5(typeNode)) {
@@ -8530,23 +8739,24 @@ var rule123 = ruleCreator({
 var typescript_require_readonly_record_type_alias_default = rule123;
 
 // dist/rules/typescript-require-readonly-set-parameter-type.js
+var import_utils69 = require("@typescript-eslint/utils");
 var functionLikeNodeSelector8 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
 var getParametersFromFunctionLikeNode5 = (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") {
+  if (node.type === import_utils69.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils69.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils69.AST_NODE_TYPES.FunctionExpression || node.type === import_utils69.AST_NODE_TYPES.TSCallSignatureDeclaration || node.type === import_utils69.AST_NODE_TYPES.TSConstructSignatureDeclaration || node.type === import_utils69.AST_NODE_TYPES.TSConstructorType || node.type === import_utils69.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils69.AST_NODE_TYPES.TSEmptyBodyFunctionExpression || node.type === import_utils69.AST_NODE_TYPES.TSFunctionType || node.type === import_utils69.AST_NODE_TYPES.TSMethodSignature) {
     return node.params;
   }
   return void 0;
 };
 var getTypeAnnotationFromPattern4 = (pattern) => {
-  if (pattern.type === "AssignmentPattern") {
+  if (pattern.type === import_utils69.AST_NODE_TYPES.AssignmentPattern) {
     return getTypeAnnotationFromPattern4(pattern.left);
   }
-  if (pattern.type === "RestElement") {
+  if (pattern.type === import_utils69.AST_NODE_TYPES.RestElement) {
     if (pattern.typeAnnotation !== void 0) {
       return pattern.typeAnnotation;
     }
     const argument = pattern.argument;
-    if (argument.type !== "ArrayPattern" && argument.type !== "Identifier" && argument.type !== "ObjectPattern") {
+    if (argument.type !== import_utils69.AST_NODE_TYPES.ArrayPattern && argument.type !== import_utils69.AST_NODE_TYPES.Identifier && argument.type !== import_utils69.AST_NODE_TYPES.ObjectPattern) {
       return void 0;
     }
     return argument.typeAnnotation;
@@ -8554,17 +8764,17 @@ var getTypeAnnotationFromPattern4 = (pattern) => {
   return pattern.typeAnnotation;
 };
 var getTypeAnnotationFromParameter4 = (parameter) => {
-  if (parameter.type === "TSParameterProperty") {
+  if (parameter.type === import_utils69.AST_NODE_TYPES.TSParameterProperty) {
     return getTypeAnnotationFromPattern4(parameter.parameter);
   }
   return getTypeAnnotationFromPattern4(parameter);
 };
-var isSetTypeReference = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Set";
+var isSetTypeReference = (node) => node.typeName.type === import_utils69.AST_NODE_TYPES.Identifier && node.typeName.name === "Set";
 var collectMutableSetTypeNodes = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils69.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils69.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableSetTypeNodes(subTypeNode));
   }
-  if (typeNode.type !== "TSTypeReference" || !isSetTypeReference(typeNode)) {
+  if (typeNode.type !== import_utils69.AST_NODE_TYPES.TSTypeReference || !isSetTypeReference(typeNode)) {
     return [];
   }
   return [typeNode.typeName];
@@ -8623,12 +8833,13 @@ var rule124 = ruleCreator({
 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";
+var import_utils70 = require("@typescript-eslint/utils");
+var isSetTypeReference2 = (node) => node.typeName.type === import_utils70.AST_NODE_TYPES.Identifier && node.typeName.name === "Set";
 var collectMutableSetTypeNodes2 = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils70.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils70.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableSetTypeNodes2(subTypeNode));
   }
-  if (typeNode.type !== "TSTypeReference" || !isSetTypeReference2(typeNode)) {
+  if (typeNode.type !== import_utils70.AST_NODE_TYPES.TSTypeReference || !isSetTypeReference2(typeNode)) {
     return [];
   }
   return [typeNode.typeName];
@@ -8636,14 +8847,11 @@ var collectMutableSetTypeNodes2 = (typeNode) => {
 var buildReadonlySetFix2 = (node) => (fixer) => fixer.replaceText(node, "ReadonlySet");
 var isTopLevelPropertySignature4 = (node) => {
   const parent = node.parent;
-  if (parent?.type === "TSInterfaceBody") {
+  if (parent.type === import_utils70.AST_NODE_TYPES.TSInterfaceBody) {
     return true;
   }
-  if (parent?.type !== "TSTypeLiteral") {
-    return false;
-  }
   const maybeTypeAliasDeclaration = parent.parent;
-  return maybeTypeAliasDeclaration?.type === "TSTypeAliasDeclaration";
+  return maybeTypeAliasDeclaration.type === import_utils70.AST_NODE_TYPES.TSTypeAliasDeclaration;
 };
 var rule125 = ruleCreator({
   create: (context) => ({
@@ -8695,19 +8903,20 @@ var rule125 = ruleCreator({
 var typescript_require_readonly_set_property_type_default = rule125;
 
 // dist/rules/typescript-require-readonly-set-return-type.js
+var import_utils71 = require("@typescript-eslint/utils");
 var functionLikeNodeSelector9 = ":matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSEmptyBodyFunctionExpression, TSFunctionType, TSMethodSignature)";
 var getReturnTypeAnnotationFromFunctionLikeNode4 = (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") {
+  if (node.type === import_utils71.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils71.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils71.AST_NODE_TYPES.FunctionExpression || node.type === import_utils71.AST_NODE_TYPES.TSCallSignatureDeclaration || node.type === import_utils71.AST_NODE_TYPES.TSConstructSignatureDeclaration || node.type === import_utils71.AST_NODE_TYPES.TSConstructorType || node.type === import_utils71.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils71.AST_NODE_TYPES.TSEmptyBodyFunctionExpression || node.type === import_utils71.AST_NODE_TYPES.TSFunctionType || node.type === import_utils71.AST_NODE_TYPES.TSMethodSignature) {
     return node.returnType;
   }
   return void 0;
 };
-var isSetTypeReference3 = (node) => node.typeName.type === "Identifier" && node.typeName.name === "Set";
+var isSetTypeReference3 = (node) => node.typeName.type === import_utils71.AST_NODE_TYPES.Identifier && node.typeName.name === "Set";
 var collectMutableSetTypeNodes3 = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils71.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils71.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableSetTypeNodes3(subTypeNode));
   }
-  if (typeNode.type !== "TSTypeReference" || !isSetTypeReference3(typeNode)) {
+  if (typeNode.type !== import_utils71.AST_NODE_TYPES.TSTypeReference || !isSetTypeReference3(typeNode)) {
     return [];
   }
   return [typeNode.typeName];
@@ -8760,12 +8969,13 @@ var rule126 = ruleCreator({
 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";
+var import_utils72 = require("@typescript-eslint/utils");
+var isSetTypeReference4 = (node) => node.typeName.type === import_utils72.AST_NODE_TYPES.Identifier && node.typeName.name === "Set";
 var collectMutableSetTypeNodes4 = (typeNode) => {
-  if (typeNode.type === "TSIntersectionType" || typeNode.type === "TSUnionType") {
+  if (typeNode.type === import_utils72.AST_NODE_TYPES.TSIntersectionType || typeNode.type === import_utils72.AST_NODE_TYPES.TSUnionType) {
     return typeNode.types.flatMap((subTypeNode) => collectMutableSetTypeNodes4(subTypeNode));
   }
-  if (typeNode.type !== "TSTypeReference" || !isSetTypeReference4(typeNode)) {
+  if (typeNode.type !== import_utils72.AST_NODE_TYPES.TSTypeReference || !isSetTypeReference4(typeNode)) {
     return [];
   }
   return [typeNode.typeName];
@@ -8814,11 +9024,12 @@ var rule127 = ruleCreator({
 var typescript_require_readonly_set_type_alias_default = rule127;
 
 // dist/rules/typescript-require-this-void.js
-var import_ts_extras67 = require("ts-extras");
+var import_utils73 = require("@typescript-eslint/utils");
+var import_ts_extras69 = 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_extras67.arrayFirst)(functionExpression.params);
-  if (firstParameter?.type === "Identifier" && firstParameter.name === "this") {
+  const firstParameter = (0, import_ts_extras69.arrayFirst)(functionExpression.params);
+  if (firstParameter?.type === import_utils73.AST_NODE_TYPES.Identifier && firstParameter.name === "this") {
     const existingTypeAnnotation = firstParameter.typeAnnotation;
     if (existingTypeAnnotation === void 0) {
       return (fixer) => fixer.insertTextAfter(firstParameter, ": void");
@@ -8836,7 +9047,7 @@ var rule128 = ruleCreator({
     const sourceCode = context.sourceCode;
     return {
       [selector24]: (node) => {
-        if (node.type !== "FunctionExpression") {
+        if (node.type !== import_utils73.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         const suggestionFix = createThisVoidSuggestionFix(sourceCode, node);
@@ -8879,9 +9090,10 @@ var rule128 = ruleCreator({
 var typescript_require_this_void_default = rule128;
 
 // dist/rules/underscore-internal.js
-var internalTagPattern = /@internal\b/u;
+var import_utils74 = require("@typescript-eslint/utils");
+var internalTagPattern = /@internal\b/v;
 var isNonUnderscoreIdentifier = (identifier) => !identifier.name.startsWith("_");
-var isExportDeclaration = (node) => node?.type === "ExportDefaultDeclaration" || node?.type === "ExportNamedDeclaration";
+var isExportDeclaration = (node) => node?.type === import_utils74.AST_NODE_TYPES.ExportDefaultDeclaration || node?.type === import_utils74.AST_NODE_TYPES.ExportNamedDeclaration;
 var rule129 = ruleCreator({
   create: (context) => {
     const hasInternalTag = (node) => {
@@ -8917,13 +9129,13 @@ var rule129 = ruleCreator({
         reportIfInternal(node.id, node);
       },
       "MethodDefinition[key.type='Identifier']": (node) => {
-        if (node.key.type !== "Identifier") {
+        if (node.key.type !== import_utils74.AST_NODE_TYPES.Identifier) {
           return;
         }
         reportIfInternal(node.key, node);
       },
       "PropertyDefinition[key.type='Identifier']": (node) => {
-        if (node.key.type !== "Identifier") {
+        if (node.key.type !== import_utils74.AST_NODE_TYPES.Identifier) {
           return;
         }
         reportIfInternal(node.key, node);
@@ -8932,7 +9144,7 @@ var rule129 = ruleCreator({
         reportIfInternal(node.id, node);
       },
       "TSEnumMember[id.type='Identifier']": (node) => {
-        if (node.id.type !== "Identifier") {
+        if (node.id.type !== import_utils74.AST_NODE_TYPES.Identifier) {
           return;
         }
         reportIfInternal(node.id, node);
@@ -8941,13 +9153,13 @@ var rule129 = ruleCreator({
         reportIfInternal(node.id, node);
       },
       "TSMethodSignature[key.type='Identifier']": (node) => {
-        if (node.key.type !== "Identifier") {
+        if (node.key.type !== import_utils74.AST_NODE_TYPES.Identifier) {
           return;
         }
         reportIfInternal(node.key, node);
       },
       "TSPropertySignature[key.type='Identifier']": (node) => {
-        if (node.key.type !== "Identifier") {
+        if (node.key.type !== import_utils74.AST_NODE_TYPES.Identifier) {
           return;
         }
         reportIfInternal(node.key, node);
@@ -8956,13 +9168,10 @@ var rule129 = ruleCreator({
         reportIfInternal(node.id, node);
       },
       "VariableDeclarator[id.type='Identifier']": (node) => {
-        if (node.id.type !== "Identifier") {
+        if (node.id.type !== import_utils74.AST_NODE_TYPES.Identifier) {
           return;
         }
         const declaration = node.parent;
-        if (declaration?.type !== "VariableDeclaration") {
-          return;
-        }
         reportIfInternal(node.id, declaration);
       }
     };
@@ -8990,7 +9199,7 @@ var underscore_internal_default = rule129;
 // dist/rules/unused-internal-properties.js
 var import_eslint_plugin_unicorn3 = __toESM(require("eslint-plugin-unicorn"), 1);
 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, {
+var deprecatedRule26 = withDeprecatedRuleLifecycle(rule130, {
   message: "Deprecated in favor of unicorn/no-unused-properties.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -9006,12 +9215,12 @@ var deprecatedRule27 = withDeprecatedRuleLifecycle(rule130, {
   ],
   ruleId: "unused-internal-properties"
 });
-var unused_internal_properties_default = deprecatedRule27;
+var unused_internal_properties_default = deprecatedRule26;
 
 // dist/rules/uppercase-iife.js
 var import_eslint_plugin_unicorn4 = __toESM(require("eslint-plugin-unicorn"), 1);
 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, {
+var deprecatedRule27 = withDeprecatedRuleLifecycle(rule131, {
   message: "Deprecated in favor of unicorn/no-unreadable-iife.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -9027,12 +9236,12 @@ var deprecatedRule28 = withDeprecatedRuleLifecycle(rule131, {
   ],
   ruleId: "uppercase-iife"
 });
-var uppercase_iife_default = deprecatedRule28;
+var uppercase_iife_default = deprecatedRule27;
 
 // dist/rules/words.js
 var import_eslint_plugin_write_good_comments_2 = __toESM(require("eslint-plugin-write-good-comments-2"), 1);
 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, {
+var deprecatedRule28 = withDeprecatedRuleLifecycle(rule132, {
   message: "Deprecated in favor of write-good-comments/write-good-comments.",
   replacedBy: [
     createReplacementRuleInfo({
@@ -9048,7 +9257,7 @@ var deprecatedRule29 = withDeprecatedRuleLifecycle(rule132, {
   ],
   ruleId: "words"
 });
-var words_default = deprecatedRule29;
+var words_default = deprecatedRule28;
 
 // dist/rules.js
 var rulesWithRequiredTypeChecking = /* @__PURE__ */ new Set([
@@ -9224,7 +9433,7 @@ var baseRules = {
   "uppercase-iife": uppercase_iife_default,
   words: words_default
 };
-var ruleCatalog = buildRuleCatalog((0, import_ts_extras68.objectKeys)(baseRules));
+var ruleCatalog = buildRuleCatalog((0, import_ts_extras70.objectKeys)(baseRules));
 var ruleCatalogEntries = ruleCatalog.ordered;
 var ruleCatalogByRuleName = ruleCatalog.byRuleName;
 var ruleCatalogByDocId = ruleCatalog.byDocId;
@@ -9233,8 +9442,9 @@ var withCatalogDocsMetadata = (ruleName, ruleModule) => {
   if (!catalogEntry) {
     throw new Error(`Missing rule catalog entry for rule "${ruleName}".`);
   }
-  const currentDocsMetadata = (0, import_ts_extras68.safeCastTo)(ruleModule.meta.docs ?? {});
-  const hasRequiredTypeChecking = (0, import_ts_extras68.setHas)(rulesWithRequiredTypeChecking, ruleName);
+  const currentDocsMetadata = ruleModule.meta.docs;
+  (0, import_ts_extras70.assertDefined)(currentDocsMetadata);
+  const hasRequiredTypeChecking = (0, import_ts_extras70.setHas)(rulesWithRequiredTypeChecking, ruleName);
   const deprecatedMetadata = ruleModule.meta.deprecated ?? false;
   const isDeprecatedRule = deprecatedMetadata !== false;
   const docsWithCatalogMetadata = {
@@ -9243,7 +9453,7 @@ var withCatalogDocsMetadata = (ruleName, ruleModule) => {
     catalogIndex: catalogEntry.catalogIndex,
     deprecated: currentDocsMetadata.deprecated ?? isDeprecatedRule,
     frozen: currentDocsMetadata.frozen ?? currentDocsMetadata.deprecated ?? isDeprecatedRule,
-    recommended: (0, import_ts_extras68.setHas)(recommendedRuleNames, ruleName),
+    recommended: (0, import_ts_extras70.setHas)(recommendedRuleNames, ruleName),
     requiresTypeChecking: currentDocsMetadata.requiresTypeChecking ?? hasRequiredTypeChecking,
     ruleName
   };
@@ -9256,7 +9466,7 @@ var withCatalogDocsMetadata = (ruleName, ruleModule) => {
     }
   };
 };
-var decoratedRuleEntries = (0, import_ts_extras68.objectEntries)(baseRules).map(([ruleName, ruleModule]) => [ruleName, withCatalogDocsMetadata(ruleName, ruleModule)]);
+var decoratedRuleEntries = (0, import_ts_extras70.objectEntries)(baseRules).map(([ruleName, ruleModule]) => [ruleName, withCatalogDocsMetadata(ruleName, ruleModule)]);
 var decoratedRulesAccumulator = {};
 for (const [ruleName, ruleModule] of decoratedRuleEntries) {
   decoratedRulesAccumulator = {
@@ -9268,26 +9478,35 @@ var decoratedRules = decoratedRulesAccumulator;
 var rules = Object.freeze(decoratedRules);
 
 // dist/configs/all-strict.js
-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_extras69.objectFromEntries)(allStrictRuleEntries);
+var allStrictRulesAccumulator = {};
+for (const [ruleName, ruleModule] of (0, import_ts_extras71.objectEntries)(rules)) {
+  allStrictRulesAccumulator = {
+    ...allStrictRulesAccumulator,
+    [`etc-misc/${ruleName}`]: ruleModule.meta.deprecated === false ? "error" : "warn"
+  };
+}
+var allStrictRules = Object.freeze(allStrictRulesAccumulator);
 var allStrict = {
   name: "etc-misc/all-strict",
   rules: allStrictRules
 };
 
 // dist/configs/all.js
-var import_ts_extras70 = require("ts-extras");
+var import_ts_extras72 = 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_extras70.objectEntries)(rules).map(([ruleName, ruleModule]) => [`etc-misc/${ruleName}`, getAllPresetSeverity(ruleModule)]);
-var allRules = (0, import_ts_extras70.objectFromEntries)(allRuleEntries);
+var allRulesAccumulator = {};
+for (const [ruleName, ruleModule] of (0, import_ts_extras72.objectEntries)(rules)) {
+  allRulesAccumulator = {
+    ...allRulesAccumulator,
+    [`etc-misc/${ruleName}`]: getAllPresetSeverity(ruleModule)
+  };
+}
+var allRules = Object.freeze(allRulesAccumulator);
 var all = {
   name: "etc-misc/all",
   rules: allRules
@@ -9347,35 +9566,41 @@ var recommended = {
 };
 
 // dist/configs/strict-type-checked.js
-var import_ts_extras72 = require("ts-extras");
+var import_ts_extras74 = require("ts-extras");
 
 // dist/configs/strict.js
-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 import_ts_extras73 = require("ts-extras");
+var recommendedRuleNames2 = (0, import_ts_extras73.safeCastTo)((0, import_ts_extras73.objectKeys)(recommended.rules));
+var strictRulesCandidate = (0, import_ts_extras73.objectFromEntries)(recommendedRuleNames2.map((ruleName) => [ruleName, "error"]));
+var hasStrictRuleCoverage = (candidateRules) => recommendedRuleNames2.every((ruleName) => candidateRules[ruleName] === "error");
+if (!hasStrictRuleCoverage(strictRulesCandidate)) {
+  throw new Error("Strict preset synthesis failed to include every recommended rule.");
+}
+var strictRules = strictRulesCandidate;
 var strict = {
   name: "etc-misc/strict",
   rules: strictRules
 };
 
 // dist/configs/strict-type-checked.js
-var additionalTypeCheckedRuleEntries = (0, import_ts_extras72.objectEntries)(rules).flatMap(([ruleName, ruleModule]) => {
+var additionalTypeCheckedRuleEntries = (0, import_ts_extras74.objectEntries)(rules).flatMap(([ruleName, ruleModule]) => {
   if (ruleModule.meta.deprecated !== false) {
     return [];
   }
-  const docsMetadata = ruleModule.meta.docs;
+  const docsMetadata = (0, import_ts_extras74.safeCastTo)(ruleModule.meta.docs);
   if (docsMetadata?.requiresTypeChecking !== true) {
     return [];
   }
   const qualifiedRuleName = `etc-misc/${ruleName}`;
-  if ((0, import_ts_extras72.keyIn)(strict.rules, qualifiedRuleName)) {
+  if ((0, import_ts_extras74.objectHasOwn)(strict.rules, qualifiedRuleName)) {
     return [];
   }
-  return [[qualifiedRuleName, "error"]];
+  const severity = "error";
+  return [[qualifiedRuleName, severity]];
 });
 var strictTypeCheckedRules = {
   ...strict.rules,
-  ...(0, import_ts_extras72.objectFromEntries)(additionalTypeCheckedRuleEntries)
+  ...(0, import_ts_extras74.objectFromEntries)(additionalTypeCheckedRuleEntries)
 };
 var strictTypeChecked = {
   languageOptions: {
@@ -9412,13 +9637,13 @@ var configs = {
 };
 
 // dist/plugin.js
-var plugin = {
+var plugin2 = {
   configs,
   meta: pluginMeta,
   processors: {},
   rules
 };
-var plugin_default = plugin;
+var plugin_default = plugin2;
 /**
  * @license Use of this source code is governed by an MIT-style license that can
  *   be found in the LICENSE file at