@pobammer-ts/eslint-cease-nonsense-rules 1.14.0 → 1.15.0

package/dist/index.js

@@ -9658,7 +9658,7 @@ function ParsePatternIntoTypes(pattern) {
   return result;
 }
 
-// node_modules/typebox/build/type/engine/template-literal/finite.mjs
+// node_modules/typebox/build/type/engine/template-literal/is-finite.mjs
 function FromLiteral(value) {
   return true;
 }
@@ -9673,7 +9673,7 @@ function FromTypes(types) {
 function FromType2(type) {
   return IsUnion(type) ? FromTypes(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : false;
 }
-function TemplateLiteralFinite(types) {
+function IsTemplateLiteralFinite(types) {
   const result = FromTypes(types);
   return result;
 }
@@ -9715,9 +9715,14 @@ function DecodeTypesAsUnion(types) {
 function DecodeTypes(types) {
   return exports_guard.IsEqual(types.length, 0) ? Unreachable() : exports_guard.IsEqual(types.length, 1) && IsLiteral(types[0]) ? types[0] : DecodeTypesAsUnion(types);
 }
-function TemplateLiteralDecode(pattern) {
+function TemplateLiteralDecodeUnsafe(pattern) {
   const types = ParsePatternIntoTypes(pattern);
-  const result = exports_guard.IsEqual(types.length, 0) ? String2() : TemplateLiteralFinite(types) ? DecodeTypes(types) : TemplateLiteralCreate(pattern);
+  const result = exports_guard.IsEqual(types.length, 0) ? String2() : IsTemplateLiteralFinite(types) ? DecodeTypes(types) : TemplateLiteralCreate(pattern);
+  return result;
+}
+function TemplateLiteralDecode(pattern) {
+  const decoded = TemplateLiteralDecodeUnsafe(pattern);
+  const result = IsTemplateLiteral(decoded) ? String2() : decoded;
   return result;
 }
 
@@ -9749,7 +9754,7 @@ function RecordPattern(type) {
 }
 function RecordKey(type) {
   const pattern = RecordPattern(type);
-  const result = exports_guard.IsEqual(pattern, StringKey) ? String2() : exports_guard.IsEqual(pattern, IntegerKey) ? Integer() : exports_guard.IsEqual(pattern, NumberKey) ? Number2() : TemplateLiteralDecode(pattern);
+  const result = exports_guard.IsEqual(pattern, StringKey) ? String2() : exports_guard.IsEqual(pattern, IntegerKey) ? Integer() : exports_guard.IsEqual(pattern, NumberKey) ? Number2() : TemplateLiteralDecodeUnsafe(pattern);
   return result;
 }
 function RecordValue(type) {
@@ -12271,7 +12276,7 @@ function FromStringKey(key, value) {
 // node_modules/typebox/build/type/engine/record/from-key-template-literal.mjs
 function FromTemplateKey(pattern, value) {
   const types = ParsePatternIntoTypes(pattern);
-  const finite = TemplateLiteralFinite(types);
+  const finite = IsTemplateLiteralFinite(types);
   const result = finite ? FromKey(TemplateLiteralDecode(pattern), value) : CreateRecord(pattern, value);
   return result;
 }
@@ -18818,6 +18823,201 @@ var no_instance_methods_without_this_default = createRule({
   name: "no-instance-methods-without-this"
 });
 
+// src/rules/no-memo-children.ts
+import { TSESTree as TSESTree6 } from "@typescript-eslint/types";
+import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
+
+// src/constants/react-sources.ts
+var REACT_SOURCES_ROBLOX = new Set(["@rbxts/react", "@rbxts/roact"]);
+var REACT_SOURCES_STANDARD = new Set(["react", "react-dom"]);
+function getReactSources(environment2) {
+  return environment2 === "roblox-ts" ? REACT_SOURCES_ROBLOX : REACT_SOURCES_STANDARD;
+}
+function isReactImport(node, reactSources) {
+  return reactSources.has(node.source.value);
+}
+
+// src/rules/no-memo-children.ts
+var DEFAULT_OPTIONS2 = {
+  allowedComponents: [],
+  environment: "roblox-ts"
+};
+function isMemoCall(node, memoIdentifiers, reactNamespaces) {
+  const { callee } = node;
+  if (callee.type === TSESTree6.AST_NODE_TYPES.Identifier)
+    return memoIdentifiers.has(callee.name);
+  if (callee.type === TSESTree6.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree6.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree6.AST_NODE_TYPES.Identifier) {
+    return reactNamespaces.has(callee.object.name) && callee.property.name === "memo";
+  }
+  return false;
+}
+function typeHasChildrenProperty(checker, type3, visited2 = new WeakSet) {
+  if (visited2.has(type3))
+    return false;
+  visited2.add(type3);
+  const allProperties = checker.getPropertiesOfType(type3);
+  for (const prop of allProperties)
+    if (prop.getName() === "children")
+      return true;
+  if (type3.isUnion()) {
+    for (const constituent of type3.types)
+      if (typeHasChildrenProperty(checker, constituent, visited2))
+        return true;
+  }
+  if (type3.isIntersection()) {
+    for (const constituent of type3.types)
+      if (typeHasChildrenProperty(checker, constituent, visited2))
+        return true;
+  }
+  const baseTypes = type3.getBaseTypes?.();
+  if (baseTypes) {
+    for (const baseType of baseTypes)
+      if (typeHasChildrenProperty(checker, baseType, visited2))
+        return true;
+  }
+  return false;
+}
+function getPropertiesTypeFromMemoCall(services, checker, node) {
+  const tsCallNode = services.esTreeNodeToTSNodeMap.get(node);
+  if (!tsCallNode)
+    return;
+  const memoResultType = checker.getTypeAtLocation(tsCallNode);
+  if (!memoResultType)
+    return;
+  const memoResultSignatures = memoResultType.getCallSignatures();
+  if (memoResultSignatures.length > 0) {
+    const [firstSignature2] = memoResultSignatures;
+    if (firstSignature2) {
+      const [propertyParameter] = firstSignature2.getParameters();
+      if (propertyParameter)
+        return checker.getTypeOfSymbol(propertyParameter);
+    }
+  }
+  if (node.typeArguments && node.typeArguments.params.length > 0) {
+    const [typeArgNode] = node.typeArguments.params;
+    if (typeArgNode) {
+      const tsTypeArgNode = services.esTreeNodeToTSNodeMap.get(typeArgNode);
+      if (tsTypeArgNode) {
+        const typeFromArgument = checker.getTypeAtLocation(tsTypeArgNode);
+        if (typeFromArgument)
+          return typeFromArgument;
+      }
+    }
+  }
+  const [firstArgument] = node.arguments;
+  if (!firstArgument)
+    return;
+  const tsNode = services.esTreeNodeToTSNodeMap.get(firstArgument);
+  if (!tsNode)
+    return;
+  const componentType = checker.getTypeAtLocation(tsNode);
+  if (!componentType)
+    return;
+  const callSignatures = componentType.getCallSignatures();
+  if (callSignatures.length === 0)
+    return;
+  const [firstSignature] = callSignatures;
+  if (!firstSignature)
+    return;
+  const parameters3 = firstSignature.getParameters();
+  if (parameters3.length === 0)
+    return;
+  const [propertiesParameter] = parameters3;
+  return propertiesParameter ? checker.getTypeOfSymbol(propertiesParameter) : undefined;
+}
+function getComponentName(node) {
+  const [firstArgument] = node.arguments;
+  if (!firstArgument)
+    return;
+  if (firstArgument.type === TSESTree6.AST_NODE_TYPES.Identifier)
+    return firstArgument.name;
+  if (firstArgument.type === TSESTree6.AST_NODE_TYPES.FunctionExpression && firstArgument.id) {
+    return firstArgument.id.name;
+  }
+  const { parent } = node;
+  if (parent?.type === TSESTree6.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree6.AST_NODE_TYPES.Identifier) {
+    return parent.id.name;
+  }
+  return;
+}
+var no_memo_children_default = createRule({
+  create(context) {
+    const options3 = {
+      ...DEFAULT_OPTIONS2,
+      ...context.options[0]
+    };
+    const reactSources = getReactSources(options3.environment);
+    const memoIdentifiers = new Set;
+    const reactNamespaces = new Set;
+    const allowedSet = new Set(options3.allowedComponents);
+    const services = ESLintUtils3.getParserServices(context);
+    const checker = services.program.getTypeChecker();
+    return {
+      CallExpression(node) {
+        if (!isMemoCall(node, memoIdentifiers, reactNamespaces))
+          return;
+        const componentName = getComponentName(node);
+        if (componentName && allowedSet.has(componentName))
+          return;
+        const propsType = getPropertiesTypeFromMemoCall(services, checker, node);
+        if (!propsType)
+          return;
+        if (typeHasChildrenProperty(checker, propsType)) {
+          context.report({
+            data: { componentName: componentName ?? "Component" },
+            messageId: "memoWithChildren",
+            node
+          });
+        }
+      },
+      ImportDeclaration(node) {
+        if (!isReactImport(node, reactSources))
+          return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === TSESTree6.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === TSESTree6.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+            reactNamespaces.add(specifier.local.name);
+          } else if (specifier.type === TSESTree6.AST_NODE_TYPES.ImportSpecifier) {
+            const importedName = specifier.imported.type === TSESTree6.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+            if (importedName === "memo")
+              memoIdentifiers.add(specifier.local.name);
+          }
+        }
+      }
+    };
+  },
+  defaultOptions: [DEFAULT_OPTIONS2],
+  meta: {
+    docs: {
+      description: "Disallow React.memo on components with children props, which defeats memoization since children change on every render."
+    },
+    messages: {
+      memoWithChildren: "React.memo is ineffective on '{{componentName}}' because it accepts a 'children' prop. " + "The 'children' prop is typically a new JSX element on every render, causing the shallow comparison " + "performed by memo to return false on every render, negating any performance benefit. " + "Either remove 'children' from the props interface, pass children via a render prop pattern, " + "or remove the React.memo wrapper entirely."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowedComponents: {
+            default: [],
+            description: "Component names to allow with children despite memo wrapper. " + "Use this for components where you've verified memoization is still beneficial.",
+            items: { type: "string" },
+            type: "array"
+          },
+          environment: {
+            default: "roblox-ts",
+            description: "The React environment: 'roblox-ts' uses @rbxts/react, 'standard' uses react.",
+            enum: ["roblox-ts", "standard"],
+            type: "string"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  },
+  name: "no-memo-children"
+});
+
 // src/rules/no-print.ts
 var no_print_default = createRule({
   create(context) {
@@ -18845,7 +19045,7 @@ var no_print_default = createRule({
 });
 
 // src/rules/no-shorthand-names.ts
-import { TSESTree as TSESTree6 } from "@typescript-eslint/types";
+import { TSESTree as TSESTree7 } from "@typescript-eslint/types";
 var isRuleOptions = Compile(build_default.Object({
   allowPropertyAccess: build_default.Optional(build_default.Array(build_default.String())),
   ignoreShorthands: build_default.Optional(build_default.Array(build_default.String())),
@@ -18854,7 +19054,7 @@ var isRuleOptions = Compile(build_default.Object({
 function isRecord2(value) {
   return value !== null && typeof value === "object";
 }
-var DEFAULT_OPTIONS2 = {
+var DEFAULT_OPTIONS3 = {
   allowPropertyAccess: ["char"],
   ignoreShorthands: [],
   shorthands: {
@@ -18984,7 +19184,7 @@ function isWordIgnored(word, ignoreMatchers, ignoreExact) {
   return false;
 }
 function normalizeOptions2(rawOptions) {
-  const mergedShorthands = { ...DEFAULT_OPTIONS2.shorthands };
+  const mergedShorthands = { ...DEFAULT_OPTIONS3.shorthands };
   if (rawOptions?.shorthands) {
     for (const [key, value] of Object.entries(rawOptions.shorthands))
       mergedShorthands[key] = value;
@@ -18998,7 +19198,7 @@ function normalizeOptions2(rawOptions) {
     else
       matchers.push(result.matcher);
   }
-  const allowPropertyAccessSource = rawOptions?.allowPropertyAccess ?? DEFAULT_OPTIONS2.allowPropertyAccess;
+  const allowPropertyAccessSource = rawOptions?.allowPropertyAccess ?? DEFAULT_OPTIONS3.allowPropertyAccess;
   const ignoreMatchers = new Array;
   const ignoreExact = new Set;
   for (const pattern4 of rawOptions?.ignoreShorthands ?? []) {
@@ -19106,9 +19306,9 @@ var noShorthandNames = {
               return;
           }
         }
-        if (identifierName === "plr" && parent?.type === TSESTree6.AST_NODE_TYPES.VariableDeclarator && parent.id === node) {
+        if (identifierName === "plr" && parent?.type === TSESTree7.AST_NODE_TYPES.VariableDeclarator && parent.id === node) {
           const { init } = parent;
-          if (init && isRecord2(init) && init.type === TSESTree6.AST_NODE_TYPES.MemberExpression && init.object !== undefined && isRecord2(init.object) && init.object.type === TSESTree6.AST_NODE_TYPES.Identifier && init.object.name === "Players" && init.property !== undefined && isRecord2(init.property) && init.property.type === TSESTree6.AST_NODE_TYPES.Identifier && init.property.name === "LocalPlayer") {
+          if (init && isRecord2(init) && init.type === TSESTree7.AST_NODE_TYPES.MemberExpression && init.object !== undefined && isRecord2(init.object) && init.object.type === TSESTree7.AST_NODE_TYPES.Identifier && init.object.name === "Players" && init.property !== undefined && isRecord2(init.property) && init.property.type === TSESTree7.AST_NODE_TYPES.Identifier && init.property.name === "LocalPlayer") {
             context.report({
               data: { replacement: "localPlayer", shorthand: "plr" },
               messageId: "useReplacement",
@@ -19752,8 +19952,817 @@ var prefer_early_return_default = createRule({
 });
 
 // src/rules/prefer-enum-item.ts
-import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
+
+// node_modules/ts-api-utils/lib/index.js
+import ts9 from "typescript";
+function isFlagSet(allFlags, flag) {
+  return (allFlags & flag) !== 0;
+}
+function isFlagSetOnObject(obj, flag) {
+  return isFlagSet(obj.flags, flag);
+}
+var isTypeFlagSet = isFlagSetOnObject;
+function includesModifier(modifiers, ...kinds) {
+  if (modifiers === undefined) {
+    return false;
+  }
+  for (const modifier of modifiers) {
+    if (kinds.includes(modifier.kind)) {
+      return true;
+    }
+  }
+  return false;
+}
+var [tsMajor, tsMinor] = ts9.versionMajorMinor.split(".").map((raw) => Number.parseInt(raw, 10));
+function isNumericOrStringLikeLiteral(node) {
+  switch (node.kind) {
+    case ts9.SyntaxKind.NoSubstitutionTemplateLiteral:
+    case ts9.SyntaxKind.NumericLiteral:
+    case ts9.SyntaxKind.StringLiteral:
+      return true;
+    default:
+      return false;
+  }
+}
+function isFunctionScopeBoundary(node) {
+  switch (node.kind) {
+    case ts9.SyntaxKind.ArrowFunction:
+    case ts9.SyntaxKind.CallSignature:
+    case ts9.SyntaxKind.ClassDeclaration:
+    case ts9.SyntaxKind.ClassExpression:
+    case ts9.SyntaxKind.Constructor:
+    case ts9.SyntaxKind.ConstructorType:
+    case ts9.SyntaxKind.ConstructSignature:
+    case ts9.SyntaxKind.EnumDeclaration:
+    case ts9.SyntaxKind.FunctionDeclaration:
+    case ts9.SyntaxKind.FunctionExpression:
+    case ts9.SyntaxKind.FunctionType:
+    case ts9.SyntaxKind.GetAccessor:
+    case ts9.SyntaxKind.MethodDeclaration:
+    case ts9.SyntaxKind.MethodSignature:
+    case ts9.SyntaxKind.ModuleDeclaration:
+    case ts9.SyntaxKind.SetAccessor:
+      return true;
+    case ts9.SyntaxKind.SourceFile:
+      return ts9.isExternalModule(node);
+    default:
+      return false;
+  }
+}
+var IntrinsicTypeFlags = ts9.TypeFlags.Intrinsic ?? ts9.TypeFlags.Any | ts9.TypeFlags.Unknown | ts9.TypeFlags.String | ts9.TypeFlags.Number | ts9.TypeFlags.BigInt | ts9.TypeFlags.Boolean | ts9.TypeFlags.BooleanLiteral | ts9.TypeFlags.ESSymbol | ts9.TypeFlags.Void | ts9.TypeFlags.Undefined | ts9.TypeFlags.Null | ts9.TypeFlags.Never | ts9.TypeFlags.NonPrimitive;
+function isUnionType(type3) {
+  return isTypeFlagSet(type3, ts9.TypeFlags.Union);
+}
+function unionConstituents(type3) {
+  return isUnionType(type3) ? type3.types : [type3];
+}
+function identifierToKeywordKind(node) {
+  return "originalKeywordKind" in node ? node.originalKeywordKind : ts9.identifierToKeywordKind(node);
+}
+function getDeclarationDomain(node) {
+  switch (node.parent.kind) {
+    case ts9.SyntaxKind.ClassDeclaration:
+    case ts9.SyntaxKind.ClassExpression:
+      return 2 | 4;
+    case ts9.SyntaxKind.EnumDeclaration:
+      return 7;
+    case ts9.SyntaxKind.FunctionDeclaration:
+    case ts9.SyntaxKind.FunctionExpression:
+      return 4;
+    case ts9.SyntaxKind.ImportClause:
+    case ts9.SyntaxKind.NamespaceImport:
+      return 7 | 8;
+    case ts9.SyntaxKind.ImportEqualsDeclaration:
+    case ts9.SyntaxKind.ImportSpecifier:
+      return node.parent.name === node ? 7 | 8 : undefined;
+    case ts9.SyntaxKind.InterfaceDeclaration:
+    case ts9.SyntaxKind.TypeAliasDeclaration:
+    case ts9.SyntaxKind.TypeParameter:
+      return 2;
+    case ts9.SyntaxKind.ModuleDeclaration:
+      return 1;
+    case ts9.SyntaxKind.Parameter:
+      if (node.parent.parent.kind === ts9.SyntaxKind.IndexSignature || identifierToKeywordKind(node) === ts9.SyntaxKind.ThisKeyword) {
+        return;
+      }
+    case ts9.SyntaxKind.BindingElement:
+    case ts9.SyntaxKind.VariableDeclaration:
+      return node.parent.name === node ? 4 : undefined;
+  }
+}
+function getPropertyName(propertyName) {
+  if (propertyName.kind === ts9.SyntaxKind.ComputedPropertyName) {
+    const expression = unwrapParentheses(propertyName.expression);
+    if (ts9.isPrefixUnaryExpression(expression)) {
+      let negate = false;
+      switch (expression.operator) {
+        case ts9.SyntaxKind.MinusToken:
+          negate = true;
+        case ts9.SyntaxKind.PlusToken:
+          return ts9.isNumericLiteral(expression.operand) ? `${negate ? "-" : ""}${expression.operand.text}` : ts9.isBigIntLiteral(expression.operand) ? `${negate ? "-" : ""}${expression.operand.text.slice(0, -1)}` : undefined;
+        default:
+          return;
+      }
+    }
+    if (ts9.isBigIntLiteral(expression)) {
+      return expression.text.slice(0, -1);
+    }
+    if (isNumericOrStringLikeLiteral(expression)) {
+      return expression.text;
+    }
+    return;
+  }
+  return propertyName.kind === ts9.SyntaxKind.PrivateIdentifier ? undefined : propertyName.text;
+}
+function unwrapParentheses(node) {
+  while (node.kind === ts9.SyntaxKind.ParenthesizedExpression) {
+    node = node.expression;
+  }
+  return node;
+}
+function getUsageDomain(node) {
+  const parent = node.parent;
+  switch (parent.kind) {
+    case ts9.SyntaxKind.BindingElement:
+      if (parent.initializer === node) {
+        return 5;
+      }
+      break;
+    case ts9.SyntaxKind.BreakStatement:
+    case ts9.SyntaxKind.ClassDeclaration:
+    case ts9.SyntaxKind.ClassExpression:
+    case ts9.SyntaxKind.ContinueStatement:
+    case ts9.SyntaxKind.EnumDeclaration:
+    case ts9.SyntaxKind.FunctionDeclaration:
+    case ts9.SyntaxKind.FunctionExpression:
+    case ts9.SyntaxKind.GetAccessor:
+    case ts9.SyntaxKind.ImportClause:
+    case ts9.SyntaxKind.ImportSpecifier:
+    case ts9.SyntaxKind.InterfaceDeclaration:
+    case ts9.SyntaxKind.JsxAttribute:
+    case ts9.SyntaxKind.LabeledStatement:
+    case ts9.SyntaxKind.MethodDeclaration:
+    case ts9.SyntaxKind.MethodSignature:
+    case ts9.SyntaxKind.ModuleDeclaration:
+    case ts9.SyntaxKind.NamedTupleMember:
+    case ts9.SyntaxKind.NamespaceExport:
+    case ts9.SyntaxKind.NamespaceExportDeclaration:
+    case ts9.SyntaxKind.NamespaceImport:
+    case ts9.SyntaxKind.PropertySignature:
+    case ts9.SyntaxKind.SetAccessor:
+    case ts9.SyntaxKind.TypeAliasDeclaration:
+    case ts9.SyntaxKind.TypeParameter:
+    case ts9.SyntaxKind.TypePredicate:
+      break;
+    case ts9.SyntaxKind.EnumMember:
+    case ts9.SyntaxKind.ImportEqualsDeclaration:
+    case ts9.SyntaxKind.Parameter:
+    case ts9.SyntaxKind.PropertyAccessExpression:
+    case ts9.SyntaxKind.PropertyAssignment:
+    case ts9.SyntaxKind.PropertyDeclaration:
+    case ts9.SyntaxKind.VariableDeclaration:
+      if (parent.name !== node) {
+        return 5;
+      }
+      break;
+    case ts9.SyntaxKind.ExportAssignment:
+      return 7;
+    case ts9.SyntaxKind.ExportSpecifier:
+      if (parent.propertyName === undefined || parent.propertyName === node) {
+        return 7;
+      }
+      break;
+    case ts9.SyntaxKind.ExpressionWithTypeArguments:
+      return parent.parent.token === ts9.SyntaxKind.ImplementsKeyword || parent.parent.parent.kind === ts9.SyntaxKind.InterfaceDeclaration ? 2 : 4;
+    case ts9.SyntaxKind.QualifiedName:
+      if (parent.left === node) {
+        if (getEntityNameParent(parent).kind === ts9.SyntaxKind.TypeQuery) {
+          return 1 | 8;
+        }
+        return 1;
+      }
+      break;
+    case ts9.SyntaxKind.TypeQuery:
+      return 5 | 8;
+    case ts9.SyntaxKind.TypeReference:
+      return identifierToKeywordKind(node) !== ts9.SyntaxKind.ConstKeyword ? 2 : undefined;
+    default:
+      return 5;
+  }
+}
+function getEntityNameParent(name) {
+  let parent = name.parent;
+  while (parent.kind === ts9.SyntaxKind.QualifiedName) {
+    parent = parent.parent;
+  }
+  return parent;
+}
+function isBlockScopeBoundary(node) {
+  switch (node.kind) {
+    case ts9.SyntaxKind.Block: {
+      const parent = node.parent;
+      return parent.kind !== ts9.SyntaxKind.CatchClause && (parent.kind === ts9.SyntaxKind.SourceFile || !isFunctionScopeBoundary(parent)) ? 2 : 0;
+    }
+    case ts9.SyntaxKind.CaseBlock:
+    case ts9.SyntaxKind.CatchClause:
+    case ts9.SyntaxKind.ForInStatement:
+    case ts9.SyntaxKind.ForOfStatement:
+    case ts9.SyntaxKind.ForStatement:
+    case ts9.SyntaxKind.WithStatement:
+      return 2;
+    default:
+      return 0;
+  }
+}
+var AbstractScope = class {
+  constructor(global) {
+    this.global = global;
+  }
+  namespaceScopes = undefined;
+  uses = [];
+  variables = /* @__PURE__ */ new Map;
+  #enumScopes = undefined;
+  addUse(use) {
+    this.uses.push(use);
+  }
+  addVariable(identifier3, name, selector, exported, domain) {
+    const variables = this.getDestinationScope(selector).getVariables();
+    const declaration = {
+      declaration: name,
+      domain,
+      exported
+    };
+    const variable = variables.get(identifier3);
+    if (variable === undefined) {
+      variables.set(identifier3, {
+        declarations: [declaration],
+        domain,
+        uses: []
+      });
+    } else {
+      variable.domain |= domain;
+      variable.declarations.push(declaration);
+    }
+  }
+  createOrReuseEnumScope(name, _exported) {
+    let scope;
+    if (this.#enumScopes === undefined) {
+      this.#enumScopes = /* @__PURE__ */ new Map;
+    } else {
+      scope = this.#enumScopes.get(name);
+    }
+    if (scope === undefined) {
+      scope = new EnumScope(this);
+      this.#enumScopes.set(name, scope);
+    }
+    return scope;
+  }
+  createOrReuseNamespaceScope(name, _exported, ambient, hasExportStatement) {
+    let scope;
+    if (this.namespaceScopes === undefined) {
+      this.namespaceScopes = /* @__PURE__ */ new Map;
+    } else {
+      scope = this.namespaceScopes.get(name);
+    }
+    if (scope === undefined) {
+      scope = new NamespaceScope(ambient, hasExportStatement, this);
+      this.namespaceScopes.set(name, scope);
+    } else {
+      scope.refresh(ambient, hasExportStatement);
+    }
+    return scope;
+  }
+  end(cb) {
+    if (this.namespaceScopes !== undefined) {
+      this.namespaceScopes.forEach((value) => value.finish(cb));
+    }
+    this.namespaceScopes = this.#enumScopes = undefined;
+    this.applyUses();
+    this.variables.forEach((variable) => {
+      for (const declaration of variable.declarations) {
+        const result = {
+          declarations: [],
+          domain: declaration.domain,
+          exported: declaration.exported,
+          inGlobalScope: this.global,
+          uses: []
+        };
+        for (const other of variable.declarations) {
+          if (other.domain & declaration.domain) {
+            result.declarations.push(other.declaration);
+          }
+        }
+        for (const use of variable.uses) {
+          if (use.domain & declaration.domain) {
+            result.uses.push(use);
+          }
+        }
+        cb(result, declaration.declaration, this);
+      }
+    });
+  }
+  getFunctionScope() {
+    return this;
+  }
+  getVariables() {
+    return this.variables;
+  }
+  markExported(_name) {}
+  addUseToParent(_use) {}
+  applyUse(use, variables = this.variables) {
+    const variable = variables.get(use.location.text);
+    if (variable === undefined || (variable.domain & use.domain) === 0) {
+      return false;
+    }
+    variable.uses.push(use);
+    return true;
+  }
+  applyUses() {
+    for (const use of this.uses) {
+      if (!this.applyUse(use)) {
+        this.addUseToParent(use);
+      }
+    }
+    this.uses = [];
+  }
+};
+var NonRootScope = class extends AbstractScope {
+  constructor(parent, boundary) {
+    super(false);
+    this.parent = parent;
+    this.boundary = boundary;
+  }
+  getDestinationScope(selector) {
+    return this.boundary & selector ? this : this.parent.getDestinationScope(selector);
+  }
+  addUseToParent(use) {
+    return this.parent.addUse(use, this);
+  }
+};
+var AbstractNamedExpressionScope = class extends NonRootScope {
+  #domain;
+  #name;
+  constructor(name, domain, parent) {
+    super(parent, 1);
+    this.#name = name;
+    this.#domain = domain;
+  }
+  addUse(use, source) {
+    if (source !== this.innerScope) {
+      return this.innerScope.addUse(use);
+    }
+    if (use.domain & this.#domain && use.location.text === this.#name.text) {
+      this.uses.push(use);
+    } else {
+      return this.parent.addUse(use, this);
+    }
+  }
+  end(cb) {
+    this.innerScope.end(cb);
+    return cb({
+      declarations: [this.#name],
+      domain: this.#domain,
+      exported: false,
+      inGlobalScope: false,
+      uses: this.uses
+    }, this.#name, this);
+  }
+  getDestinationScope() {
+    return this.innerScope;
+  }
+  getFunctionScope() {
+    return this.innerScope;
+  }
+};
+var BlockScope = class extends NonRootScope {
+  #functionScope;
+  constructor(functionScope, parent) {
+    super(parent, 2);
+    this.#functionScope = functionScope;
+  }
+  getFunctionScope() {
+    return this.#functionScope;
+  }
+};
+var ClassExpressionScope = class extends AbstractNamedExpressionScope {
+  innerScope = new NonRootScope(this, 1);
+  constructor(name, parent) {
+    super(name, 4 | 2, parent);
+  }
+};
+var ConditionalTypeScope = class extends NonRootScope {
+  #state = 0;
+  constructor(parent) {
+    super(parent, 8);
+  }
+  addUse(use) {
+    if (this.#state === 2) {
+      return void this.uses.push(use);
+    }
+    return this.parent.addUse(use, this);
+  }
+  updateState(newState) {
+    this.#state = newState;
+  }
+};
+var EnumScope = class extends NonRootScope {
+  constructor(parent) {
+    super(parent, 1);
+  }
+  end() {
+    this.applyUses();
+  }
+};
+var FunctionScope = class extends NonRootScope {
+  constructor(parent) {
+    super(parent, 1);
+  }
+  beginBody() {
+    this.applyUses();
+  }
+};
+var FunctionExpressionScope = class extends AbstractNamedExpressionScope {
+  innerScope = new FunctionScope(this);
+  constructor(name, parent) {
+    super(name, 4, parent);
+  }
+  beginBody() {
+    return this.innerScope.beginBody();
+  }
+};
+var NamespaceScope = class extends NonRootScope {
+  #ambient;
+  #exports = undefined;
+  #hasExport;
+  #innerScope = new NonRootScope(this, 1);
+  constructor(ambient, hasExport, parent) {
+    super(parent, 1);
+    this.#ambient = ambient;
+    this.#hasExport = hasExport;
+  }
+  addUse(use, source) {
+    if (source !== this.#innerScope) {
+      return this.#innerScope.addUse(use);
+    }
+    this.uses.push(use);
+  }
+  createOrReuseEnumScope(name, exported) {
+    if (!exported && (!this.#ambient || this.#hasExport)) {
+      return this.#innerScope.createOrReuseEnumScope(name, exported);
+    }
+    return super.createOrReuseEnumScope(name, exported);
+  }
+  createOrReuseNamespaceScope(name, exported, ambient, hasExportStatement) {
+    if (!exported && (!this.#ambient || this.#hasExport)) {
+      return this.#innerScope.createOrReuseNamespaceScope(name, exported, ambient || this.#ambient, hasExportStatement);
+    }
+    return super.createOrReuseNamespaceScope(name, exported, ambient || this.#ambient, hasExportStatement);
+  }
+  end(cb) {
+    this.#innerScope.end((variable, key, scope) => {
+      if (scope !== this.#innerScope || !variable.exported && (!this.#ambient || this.#exports !== undefined && !this.#exports.has(key.text))) {
+        return cb(variable, key, scope);
+      }
+      const namespaceVar = this.variables.get(key.text);
+      if (namespaceVar === undefined) {
+        this.variables.set(key.text, {
+          declarations: variable.declarations.map(mapDeclaration),
+          domain: variable.domain,
+          uses: [...variable.uses]
+        });
+      } else {
+        outer:
+          for (const declaration of variable.declarations) {
+            for (const existing of namespaceVar.declarations) {
+              if (existing.declaration === declaration) {
+                continue outer;
+              }
+              namespaceVar.declarations.push(mapDeclaration(declaration));
+            }
+          }
+        namespaceVar.domain |= variable.domain;
+        for (const use of variable.uses) {
+          if (namespaceVar.uses.includes(use)) {
+            continue;
+          }
+          namespaceVar.uses.push(use);
+        }
+      }
+    });
+    this.applyUses();
+    this.#innerScope = new NonRootScope(this, 1);
+  }
+  finish(cb) {
+    return super.end(cb);
+  }
+  getDestinationScope() {
+    return this.#innerScope;
+  }
+  markExported(name) {
+    if (this.#exports === undefined) {
+      this.#exports = /* @__PURE__ */ new Set;
+    }
+    this.#exports.add(name.text);
+  }
+  refresh(ambient, hasExport) {
+    this.#ambient = ambient;
+    this.#hasExport = hasExport;
+  }
+};
+var RootScope = class extends AbstractScope {
+  #exportAll;
+  #exports = undefined;
+  #innerScope = new NonRootScope(this, 1);
+  constructor(exportAll, global) {
+    super(global);
+    this.#exportAll = exportAll;
+  }
+  addUse(use, origin) {
+    if (origin === this.#innerScope) {
+      return super.addUse(use);
+    }
+    return this.#innerScope.addUse(use);
+  }
+  addVariable(identifier3, name, selector, exported, domain) {
+    if (domain & 8) {
+      return super.addVariable(identifier3, name, selector, exported, domain);
+    }
+    return this.#innerScope.addVariable(identifier3, name, selector, exported, domain);
+  }
+  end(cb) {
+    this.#innerScope.end((value, key) => {
+      value.exported ||= this.#exportAll || this.#exports !== undefined && this.#exports.includes(key.text);
+      value.inGlobalScope = this.global;
+      return cb(value, key, this);
+    });
+    return super.end((value, key, scope) => {
+      value.exported ||= scope === this && this.#exports !== undefined && this.#exports.includes(key.text);
+      return cb(value, key, scope);
+    });
+  }
+  getDestinationScope() {
+    return this;
+  }
+  markExported(id2) {
+    if (this.#exports === undefined) {
+      this.#exports = [id2.text];
+    } else {
+      this.#exports.push(id2.text);
+    }
+  }
+};
+function mapDeclaration(declaration) {
+  return {
+    declaration,
+    domain: getDeclarationDomain(declaration),
+    exported: true
+  };
+}
+var UsageWalker = class {
+  #result = /* @__PURE__ */ new Map;
+  #scope;
+  getUsage(sourceFile) {
+    const variableCallback = (variable, key) => {
+      this.#result.set(key, variable);
+    };
+    const isModule = ts9.isExternalModule(sourceFile);
+    this.#scope = new RootScope(sourceFile.isDeclarationFile && isModule && !containsExportStatement(sourceFile), !isModule);
+    const cb = (node) => {
+      if (isBlockScopeBoundary(node)) {
+        return continueWithScope(node, new BlockScope(this.#scope.getFunctionScope(), this.#scope), handleBlockScope);
+      }
+      switch (node.kind) {
+        case ts9.SyntaxKind.ArrowFunction:
+        case ts9.SyntaxKind.CallSignature:
+        case ts9.SyntaxKind.Constructor:
+        case ts9.SyntaxKind.ConstructorType:
+        case ts9.SyntaxKind.ConstructSignature:
+        case ts9.SyntaxKind.FunctionDeclaration:
+        case ts9.SyntaxKind.FunctionExpression:
+        case ts9.SyntaxKind.FunctionType:
+        case ts9.SyntaxKind.GetAccessor:
+        case ts9.SyntaxKind.MethodDeclaration:
+        case ts9.SyntaxKind.MethodSignature:
+        case ts9.SyntaxKind.SetAccessor:
+          return this.#handleFunctionLikeDeclaration(node, cb, variableCallback);
+        case ts9.SyntaxKind.ClassDeclaration:
+          this.#handleDeclaration(node, true, 4 | 2);
+          return continueWithScope(node, new NonRootScope(this.#scope, 1));
+        case ts9.SyntaxKind.ClassExpression:
+          return continueWithScope(node, node.name !== undefined ? new ClassExpressionScope(node.name, this.#scope) : new NonRootScope(this.#scope, 1));
+        case ts9.SyntaxKind.ConditionalType:
+          return this.#handleConditionalType(node, cb, variableCallback);
+        case ts9.SyntaxKind.EnumDeclaration:
+          this.#handleDeclaration(node, true, 7);
+          return continueWithScope(node, this.#scope.createOrReuseEnumScope(node.name.text, includesModifier(node.modifiers, ts9.SyntaxKind.ExportKeyword)));
+        case ts9.SyntaxKind.EnumMember:
+          this.#scope.addVariable(getPropertyName(node.name), node.name, 1, true, 4);
+          break;
+        case ts9.SyntaxKind.ExportAssignment:
+          if (node.expression.kind === ts9.SyntaxKind.Identifier) {
+            return this.#scope.markExported(node.expression);
+          }
+          break;
+        case ts9.SyntaxKind.ExportSpecifier:
+          if (node.propertyName !== undefined) {
+            return this.#scope.markExported(node.propertyName, node.name);
+          }
+          return this.#scope.markExported(node.name);
+        case ts9.SyntaxKind.Identifier: {
+          const domain = getUsageDomain(node);
+          if (domain !== undefined) {
+            this.#scope.addUse({ domain, location: node });
+          }
+          return;
+        }
+        case ts9.SyntaxKind.ImportClause:
+        case ts9.SyntaxKind.ImportEqualsDeclaration:
+        case ts9.SyntaxKind.ImportSpecifier:
+        case ts9.SyntaxKind.NamespaceImport:
+          this.#handleDeclaration(node, false, 7 | 8);
+          break;
+        case ts9.SyntaxKind.InterfaceDeclaration:
+        case ts9.SyntaxKind.TypeAliasDeclaration:
+          this.#handleDeclaration(node, true, 2);
+          return continueWithScope(node, new NonRootScope(this.#scope, 4));
+        case ts9.SyntaxKind.MappedType:
+          return continueWithScope(node, new NonRootScope(this.#scope, 4));
+        case ts9.SyntaxKind.ModuleDeclaration:
+          return this.#handleModule(node, continueWithScope);
+        case ts9.SyntaxKind.Parameter:
+          if (node.parent.kind !== ts9.SyntaxKind.IndexSignature && (node.name.kind !== ts9.SyntaxKind.Identifier || identifierToKeywordKind(node.name) !== ts9.SyntaxKind.ThisKeyword)) {
+            this.#handleBindingName(node.name, false, false);
+          }
+          break;
+        case ts9.SyntaxKind.TypeParameter:
+          this.#scope.addVariable(node.name.text, node.name, node.parent.kind === ts9.SyntaxKind.InferType ? 8 : 7, false, 2);
+          break;
+        case ts9.SyntaxKind.VariableDeclarationList:
+          this.#handleVariableDeclaration(node);
+          break;
+      }
+      return ts9.forEachChild(node, cb);
+    };
+    const continueWithScope = (node, scope, next = forEachChild) => {
+      const savedScope = this.#scope;
+      this.#scope = scope;
+      next(node);
+      this.#scope.end(variableCallback);
+      this.#scope = savedScope;
+    };
+    const handleBlockScope = (node) => {
+      if (node.kind === ts9.SyntaxKind.CatchClause && node.variableDeclaration !== undefined) {
+        this.#handleBindingName(node.variableDeclaration.name, true, false);
+      }
+      return ts9.forEachChild(node, cb);
+    };
+    ts9.forEachChild(sourceFile, cb);
+    this.#scope.end(variableCallback);
+    return this.#result;
+    function forEachChild(node) {
+      return ts9.forEachChild(node, cb);
+    }
+  }
+  #handleBindingName(name, blockScoped, exported) {
+    if (name.kind === ts9.SyntaxKind.Identifier) {
+      return this.#scope.addVariable(name.text, name, blockScoped ? 3 : 1, exported, 4);
+    }
+    forEachDestructuringIdentifier(name, (declaration) => {
+      this.#scope.addVariable(declaration.name.text, declaration.name, blockScoped ? 3 : 1, exported, 4);
+    });
+  }
+  #handleConditionalType(node, cb, varCb) {
+    const savedScope = this.#scope;
+    const scope = this.#scope = new ConditionalTypeScope(savedScope);
+    cb(node.checkType);
+    scope.updateState(1);
+    cb(node.extendsType);
+    scope.updateState(2);
+    cb(node.trueType);
+    scope.updateState(3);
+    cb(node.falseType);
+    scope.end(varCb);
+    this.#scope = savedScope;
+  }
+  #handleDeclaration(node, blockScoped, domain) {
+    if (node.name !== undefined) {
+      this.#scope.addVariable(node.name.text, node.name, blockScoped ? 3 : 1, includesModifier(node.modifiers, ts9.SyntaxKind.ExportKeyword), domain);
+    }
+  }
+  #handleFunctionLikeDeclaration(node, cb, varCb) {
+    if (ts9.canHaveDecorators(node)) {
+      ts9.getDecorators(node)?.forEach(cb);
+    }
+    const savedScope = this.#scope;
+    if (node.kind === ts9.SyntaxKind.FunctionDeclaration) {
+      this.#handleDeclaration(node, false, 4);
+    }
+    const scope = this.#scope = node.kind === ts9.SyntaxKind.FunctionExpression && node.name !== undefined ? new FunctionExpressionScope(node.name, savedScope) : new FunctionScope(savedScope);
+    if (node.name !== undefined) {
+      cb(node.name);
+    }
+    if (node.typeParameters !== undefined) {
+      node.typeParameters.forEach(cb);
+    }
+    node.parameters.forEach(cb);
+    if (node.type !== undefined) {
+      cb(node.type);
+    }
+    if (node.body !== undefined) {
+      scope.beginBody();
+      cb(node.body);
+    }
+    scope.end(varCb);
+    this.#scope = savedScope;
+  }
+  #handleModule(node, next) {
+    if (node.flags & ts9.NodeFlags.GlobalAugmentation) {
+      return next(node, this.#scope.createOrReuseNamespaceScope("-global", false, true, false));
+    }
+    if (node.name.kind === ts9.SyntaxKind.Identifier) {
+      const exported = isNamespaceExported(node);
+      this.#scope.addVariable(node.name.text, node.name, 1, exported, 1 | 4);
+      const ambient = includesModifier(node.modifiers, ts9.SyntaxKind.DeclareKeyword);
+      return next(node, this.#scope.createOrReuseNamespaceScope(node.name.text, exported, ambient, ambient && namespaceHasExportStatement(node)));
+    }
+    return next(node, this.#scope.createOrReuseNamespaceScope(`"${node.name.text}"`, false, true, namespaceHasExportStatement(node)));
+  }
+  #handleVariableDeclaration(declarationList) {
+    const blockScoped = isBlockScopedVariableDeclarationList(declarationList);
+    const exported = declarationList.parent.kind === ts9.SyntaxKind.VariableStatement && includesModifier(declarationList.parent.modifiers, ts9.SyntaxKind.ExportKeyword);
+    for (const declaration of declarationList.declarations) {
+      this.#handleBindingName(declaration.name, blockScoped, exported);
+    }
+  }
+};
+function containsExportStatement(block) {
+  for (const statement of block.statements) {
+    if (statement.kind === ts9.SyntaxKind.ExportDeclaration || statement.kind === ts9.SyntaxKind.ExportAssignment) {
+      return true;
+    }
+  }
+  return false;
+}
+function forEachDestructuringIdentifier(pattern4, fn) {
+  for (const element of pattern4.elements) {
+    if (element.kind !== ts9.SyntaxKind.BindingElement) {
+      continue;
+    }
+    let result;
+    if (element.name.kind === ts9.SyntaxKind.Identifier) {
+      result = fn(element);
+    } else {
+      result = forEachDestructuringIdentifier(element.name, fn);
+    }
+    if (result) {
+      return result;
+    }
+  }
+}
+function isBlockScopedVariableDeclarationList(declarationList) {
+  return (declarationList.flags & ts9.NodeFlags.BlockScoped) !== 0;
+}
+function isNamespaceExported(node) {
+  return node.parent.kind === ts9.SyntaxKind.ModuleDeclaration || includesModifier(node.modifiers, ts9.SyntaxKind.ExportKeyword);
+}
+function namespaceHasExportStatement(ns) {
+  if (ns.body === undefined || ns.body.kind !== ts9.SyntaxKind.ModuleBlock) {
+    return false;
+  }
+  return containsExportStatement(ns.body);
+}
+
+// src/rules/prefer-enum-item.ts
+import { SymbolFlags } from "typescript";
+function isJSXAttributeValue(node) {
+  const { parent } = node;
+  return parent !== undefined && parent.type === AST_NODE_TYPES7.JSXAttribute && parent.value === node;
+}
+function canHaveContextualEnumType(node) {
+  const { parent } = node;
+  if (parent === undefined)
+    return false;
+  switch (parent.type) {
+    case AST_NODE_TYPES7.CallExpression:
+    case AST_NODE_TYPES7.NewExpression:
+      return parent.arguments.includes(node);
+    case AST_NODE_TYPES7.Property:
+      return parent.value === node;
+    case AST_NODE_TYPES7.JSXAttribute:
+      return parent.value === node;
+    case AST_NODE_TYPES7.VariableDeclarator: {
+      if (parent.init !== node)
+        return false;
+      const { id: id2 } = parent;
+      return id2.type === AST_NODE_TYPES7.Identifier && id2.typeAnnotation !== undefined;
+    }
+    default:
+      return false;
+  }
+}
 var ENUM_PREFIX = "Enum.";
+var enumLiteralIndexCache = new WeakMap;
 function getFullEnumPath(checker, type3) {
   const symbol3 = type3.getSymbol();
   if (symbol3 === undefined)
@@ -19775,8 +20784,8 @@ function getPropertyLiteralType(checker, type3, propertyName) {
   return;
 }
 function getUnionTypes(type3) {
-  if (type3.isUnion())
-    return type3.types;
+  if (isUnionType(type3))
+    return unionConstituents(type3);
   return [type3];
 }
 function createEnumMatch(enumPath) {
@@ -19784,14 +20793,153 @@ function createEnumMatch(enumPath) {
 }
 var prefer_enum_item_default = createRule({
   create(context) {
-    const [{ fixNumericToValue = false } = {}] = context.options;
-    const services = ESLintUtils3.getParserServices(context);
+    const [{ fixNumericToValue = false, performanceMode = false } = {}] = context.options;
+    const services = ESLintUtils4.getParserServices(context);
     const checker = services.program.getTypeChecker();
+    const unionTypesCache = new WeakMap;
+    const enumPathCache = new WeakMap;
+    const enumItemInfoCache = new WeakMap;
+    const enumLookupCache = new WeakMap;
+    function getUnionTypesCached(type3) {
+      const cached = unionTypesCache.get(type3);
+      if (cached !== undefined)
+        return cached;
+      const resolved = isUnionType(type3) ? unionConstituents(type3) : [type3];
+      unionTypesCache.set(type3, resolved);
+      return resolved;
+    }
+    function getFullEnumPathCached(type3) {
+      const cached = enumPathCache.get(type3);
+      if (cached !== undefined)
+        return cached === false ? undefined : cached;
+      const resolved = getFullEnumPath(checker, type3);
+      enumPathCache.set(type3, resolved ?? false);
+      return resolved;
+    }
+    function getEnumItemInfo(type3) {
+      const cached = enumItemInfoCache.get(type3);
+      if (cached !== undefined)
+        return cached === false ? undefined : cached;
+      const enumPath = getFullEnumPathCached(type3);
+      if (enumPath === undefined) {
+        enumItemInfoCache.set(type3, false);
+        return;
+      }
+      const nameLiteral = getPropertyLiteralType(checker, type3, "Name");
+      const valueLiteral = getPropertyLiteralType(checker, type3, "Value");
+      const info = {
+        enumPath,
+        ...typeof nameLiteral === "string" ? { nameLiteral } : {},
+        ...typeof valueLiteral === "number" ? { valueLiteral } : {}
+      };
+      enumItemInfoCache.set(type3, info);
+      return info;
+    }
+    function getEnumLookup(type3) {
+      const cached = enumLookupCache.get(type3);
+      if (cached !== undefined)
+        return cached === false ? undefined : cached;
+      const unionTypes = getUnionTypesCached(type3);
+      const stringMap = new Map;
+      const numberMap = new Map;
+      let hasAny = false;
+      for (const memberType of unionTypes) {
+        const info = getEnumItemInfo(memberType);
+        if (info === undefined)
+          continue;
+        hasAny = true;
+        if (info.nameLiteral !== undefined && !stringMap.has(info.nameLiteral)) {
+          stringMap.set(info.nameLiteral, info.enumPath);
+        }
+        if (info.valueLiteral !== undefined && !numberMap.has(info.valueLiteral)) {
+          numberMap.set(info.valueLiteral, info.enumPath);
+        }
+      }
+      if (!hasAny) {
+        enumLookupCache.set(type3, false);
+        return;
+      }
+      const lookup = { numberMap, stringMap };
+      enumLookupCache.set(type3, lookup);
+      return lookup;
+    }
+    function resolveAliasSymbol(symbol3) {
+      if ((symbol3.flags & SymbolFlags.Alias) !== 0)
+        return checker.getAliasedSymbol(symbol3);
+      return symbol3;
+    }
+    function buildEnumLiteralIndex(anchorNode) {
+      const resolved = checker.resolveName("Enum", anchorNode, SymbolFlags.Namespace, false);
+      if (resolved === undefined)
+        return;
+      const enumSymbol = resolveAliasSymbol(resolved);
+      if ((enumSymbol.flags & SymbolFlags.Namespace) === 0)
+        return;
+      const stringSet = new Set;
+      const numberSet = new Set;
+      const stack = [enumSymbol];
+      const visited2 = new Set;
+      while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+          continue;
+        if (visited2.has(current))
+          continue;
+        visited2.add(current);
+        const exports = checker.getExportsOfModule(current);
+        for (const exportSymbol of exports) {
+          const unaliased = resolveAliasSymbol(exportSymbol);
+          if ((unaliased.flags & SymbolFlags.Namespace) !== 0) {
+            stack.push(unaliased);
+            continue;
+          }
+          const type3 = checker.getTypeOfSymbol(unaliased);
+          const info = getEnumItemInfo(type3);
+          if (info === undefined)
+            continue;
+          if (info.nameLiteral !== undefined)
+            stringSet.add(info.nameLiteral);
+          if (info.valueLiteral !== undefined)
+            numberSet.add(info.valueLiteral);
+        }
+      }
+      if (stringSet.size === 0 && numberSet.size === 0)
+        return;
+      return { numberSet, stringSet };
+    }
+    function getEnumLiteralIndex(anchorNode) {
+      const cached = enumLiteralIndexCache.get(checker);
+      if (cached !== undefined)
+        return cached === false ? undefined : cached;
+      const built = buildEnumLiteralIndex(anchorNode);
+      enumLiteralIndexCache.set(checker, built ?? false);
+      return built;
+    }
     function getContextualType(node) {
       const tsNode = services.esTreeNodeToTSNodeMap.get(node);
       return checker.getContextualType(tsNode);
     }
+    function shouldSkipLiteral(node, value) {
+      if (!performanceMode)
+        return false;
+      const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+      if (tsNode === undefined)
+        return false;
+      const index2 = getEnumLiteralIndex(tsNode);
+      if (index2 === undefined)
+        return false;
+      if (typeof value === "string")
+        return !index2.stringSet.has(value);
+      return !index2.numberSet.has(value);
+    }
     function findEnumMatch(contextualType, literalValue) {
+      if (performanceMode) {
+        const lookup = getEnumLookup(contextualType);
+        if (lookup === undefined)
+          return;
+        const enumPath = typeof literalValue === "string" ? lookup.stringMap.get(literalValue) : lookup.numberMap.get(literalValue);
+        return enumPath === undefined ? undefined : createEnumMatch(enumPath);
+      }
       const unionTypes = getUnionTypes(contextualType);
       for (const memberType of unionTypes) {
         const enumPath = getFullEnumPath(checker, memberType);
@@ -19814,6 +20962,10 @@ var prefer_enum_item_default = createRule({
         const { value } = node;
         if (typeof value !== "string" && typeof value !== "number")
           return;
+        if (!canHaveContextualEnumType(node))
+          return;
+        if (shouldSkipLiteral(node, value))
+          return;
         const contextualType = getContextualType(node);
         if (contextualType === undefined)
           return;
@@ -19823,6 +20975,8 @@ var prefer_enum_item_default = createRule({
         const isString = typeof value === "string";
         const displayValue = isString ? `"${value}"` : String(value);
         const fixPath = fixNumericToValue && !isString ? `${match.enumPath}.Value` : match.enumPath;
+        const needsJSXBraces = isJSXAttributeValue(node);
+        const fixText = needsJSXBraces ? `{${fixPath}}` : fixPath;
         context.report({
           data: {
             enumType: match.enumPath.split(".").slice(0, -1).join("."),
@@ -19830,7 +20984,7 @@ var prefer_enum_item_default = createRule({
             value: displayValue
           },
           fix(fixer) {
-            return fixer.replaceText(node, fixPath);
+            return fixer.replaceText(node, fixText);
           },
           messageId: "preferEnumItem",
           node
@@ -19838,7 +20992,7 @@ var prefer_enum_item_default = createRule({
       }
     };
   },
-  defaultOptions: [{}],
+  defaultOptions: [{ fixNumericToValue: false, performanceMode: false }],
   meta: {
     docs: {
       description: "Enforce using EnumItem values instead of string or number literals."
@@ -19855,6 +21009,11 @@ var prefer_enum_item_default = createRule({
             default: false,
             description: "When true, numeric literals fix to Enum.X.Y.Value instead of Enum.X.Y",
             type: "boolean"
+          },
+          performanceMode: {
+            default: false,
+            description: "When true, uses caching to speed up enum lookups without changing behavior",
+            type: "boolean"
           }
         },
         type: "object"
@@ -19867,7 +21026,7 @@ var prefer_enum_item_default = createRule({
 
 // src/rules/prefer-module-scope-constants.ts
 var import_scope_manager3 = __toESM(require_dist2(), 1);
-import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
 var SCREAMING_SNAKE_CASE = /^[A-Z][A-Z0-9_]*$/;
 function isTopScope(scope) {
   const { type: type3 } = scope;
@@ -19875,7 +21034,7 @@ function isTopScope(scope) {
     return true;
   if (scope.upper?.type === import_scope_manager3.ScopeType.global) {
     const { block } = scope.upper;
-    if (block.type === AST_NODE_TYPES7.Program && block.sourceType === "script")
+    if (block.type === AST_NODE_TYPES8.Program && block.sourceType === "script")
       return true;
   }
   return false;
@@ -19892,7 +21051,7 @@ var prefer_module_scope_constants_default = createRule({
       },
       VariableDeclarator(node) {
         const { id: id2 } = node;
-        if (id2.type !== AST_NODE_TYPES7.Identifier || !SCREAMING_SNAKE_CASE.test(id2.name))
+        if (id2.type !== AST_NODE_TYPES8.Identifier || !SCREAMING_SNAKE_CASE.test(id2.name))
           return;
         if (!inConstDeclaration) {
           context.report({
@@ -19927,7 +21086,7 @@ var prefer_module_scope_constants_default = createRule({
 });
 
 // src/rules/prefer-pascal-case-enums.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/utils";
 
 // src/utilities/casing-utilities.ts
 var SPLIT_LOWER_TO_UPPER = regex2("([\\p{Ll}\\d])(\\p{Lu})", "gu");
@@ -19967,9 +21126,9 @@ function toPascalCase(value) {
 // src/rules/prefer-pascal-case-enums.ts
 var STARTS_WITH_DIGIT = regex2("^\\d");
 function getIdentifierName(node) {
-  if (node.type === AST_NODE_TYPES8.Identifier)
+  if (node.type === AST_NODE_TYPES9.Identifier)
     return node.name;
-  if (node.type !== AST_NODE_TYPES8.Literal || typeof node.value !== "string")
+  if (node.type !== AST_NODE_TYPES9.Literal || typeof node.value !== "string")
     return;
   return STARTS_WITH_DIGIT.test(node.value) ? undefined : node.value;
 }
@@ -20012,17 +21171,17 @@ var prefer_pascal_case_enums_default = createRule({
 });
 
 // src/utilities/pattern-replacement/pattern-matcher.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
 
 // src/utilities/pattern-replacement/constant-folder.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/types";
 function normalizeZero(num) {
   return Object.is(num, -0) ? 0 : num;
 }
 function unwrap(node) {
   switch (node.type) {
-    case AST_NODE_TYPES9.TSAsExpression:
-    case AST_NODE_TYPES9.TSNonNullExpression:
+    case AST_NODE_TYPES10.TSAsExpression:
+    case AST_NODE_TYPES10.TSNonNullExpression:
       return unwrap(node.expression);
     default:
       return node;
@@ -20030,10 +21189,10 @@ function unwrap(node) {
 }
 function evaluateConstant(node) {
   const expression = unwrap(node);
-  if (expression.type === AST_NODE_TYPES9.Literal && typeof expression.value === "number") {
+  if (expression.type === AST_NODE_TYPES10.Literal && typeof expression.value === "number") {
     return normalizeZero(expression.value);
   }
-  if (expression.type === AST_NODE_TYPES9.UnaryExpression) {
+  if (expression.type === AST_NODE_TYPES10.UnaryExpression) {
     const argument = evaluateConstant(expression.argument);
     if (argument === undefined)
       return;
@@ -20046,8 +21205,8 @@ function evaluateConstant(node) {
         return;
     }
   }
-  if (expression.type === AST_NODE_TYPES9.BinaryExpression) {
-    if (expression.left.type === AST_NODE_TYPES9.PrivateIdentifier)
+  if (expression.type === AST_NODE_TYPES10.BinaryExpression) {
+    if (expression.left.type === AST_NODE_TYPES10.PrivateIdentifier)
       return;
     const left = evaluateConstant(expression.left);
     const right = evaluateConstant(expression.right);
@@ -20090,14 +21249,14 @@ function buildPatternIndex(patterns2) {
 }
 function resolveCallee(node) {
   const callee = unwrap(node.callee);
-  if (node.type === AST_NODE_TYPES10.NewExpression && callee.type === AST_NODE_TYPES10.Identifier) {
+  if (node.type === AST_NODE_TYPES11.NewExpression && callee.type === AST_NODE_TYPES11.Identifier) {
     return { kind: "constructor", typeName: callee.name };
   }
-  if (node.type === AST_NODE_TYPES10.CallExpression) {
-    const member = callee.type === AST_NODE_TYPES10.ChainExpression ? unwrap(callee.expression) : callee;
-    if (member.type === AST_NODE_TYPES10.MemberExpression && !member.computed) {
+  if (node.type === AST_NODE_TYPES11.CallExpression) {
+    const member = callee.type === AST_NODE_TYPES11.ChainExpression ? unwrap(callee.expression) : callee;
+    if (member.type === AST_NODE_TYPES11.MemberExpression && !member.computed) {
       const object3 = unwrap(member.object);
-      if (object3.type === AST_NODE_TYPES10.Identifier && member.property.type === AST_NODE_TYPES10.Identifier) {
+      if (object3.type === AST_NODE_TYPES11.Identifier && member.property.type === AST_NODE_TYPES11.Identifier) {
         return {
           kind: "staticMethod",
           methodName: member.property.name,
@@ -20114,9 +21273,9 @@ function captureParameter(node, sourceCode) {
   const constValue = evaluateConstant(expression);
   let expressionKey;
   let isComplex = false;
-  if (expression.type === AST_NODE_TYPES10.Literal && typeof expression.value === "number") {
+  if (expression.type === AST_NODE_TYPES11.Literal && typeof expression.value === "number") {
     expressionKey = `literal:${normalizeZero(expression.value)}`;
-  } else if (expression.type === AST_NODE_TYPES10.Identifier) {
+  } else if (expression.type === AST_NODE_TYPES11.Identifier) {
     if (expression.name === "undefined")
       expressionKey = "undefined";
     else
@@ -20142,7 +21301,7 @@ function matchParameters(patterns2, parameters3, sourceCode) {
       continue;
     const parameter2 = parameters3[index2];
     const unwrappedParameter = parameter2 === undefined ? undefined : unwrap(parameter2);
-    const isMissing = parameter2 === undefined || unwrappedParameter?.type === AST_NODE_TYPES10.Identifier && unwrappedParameter.name === "undefined";
+    const isMissing = parameter2 === undefined || unwrappedParameter?.type === AST_NODE_TYPES11.Identifier && unwrappedParameter.name === "undefined";
     if (pattern4.kind === "literal") {
       if (isMissing)
         return;
@@ -20432,13 +21591,13 @@ var prefer_pattern_replacements_default = createRule({
 });
 
 // src/rules/prefer-sequence-overloads.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES12 } from "@typescript-eslint/types";
 var sequenceDescriptors = [
   { keypointName: "ColorSequenceKeypoint", sequenceName: "ColorSequence" },
   { keypointName: "NumberSequenceKeypoint", sequenceName: "NumberSequence" }
 ];
 function isSequenceIdentifier(node) {
-  if (node.type !== AST_NODE_TYPES11.Identifier)
+  if (node.type !== AST_NODE_TYPES12.Identifier)
     return false;
   for (const { sequenceName } of sequenceDescriptors)
     if (sequenceName === node.name)
@@ -20452,16 +21611,16 @@ function findDescriptor(sequenceName) {
   return;
 }
 var isNumericLiteral = Compile(build_default.Object({
-  type: build_default.Literal(AST_NODE_TYPES11.Literal),
+  type: build_default.Literal(AST_NODE_TYPES12.Literal),
   value: build_default.Number()
 }));
 function isExpressionArgument(argument) {
-  return argument !== undefined && argument.type !== AST_NODE_TYPES11.SpreadElement;
+  return argument !== undefined && argument.type !== AST_NODE_TYPES12.SpreadElement;
 }
 function extractKeypoint(element, descriptor) {
-  if (element === undefined || element.type !== AST_NODE_TYPES11.NewExpression)
+  if (element === undefined || element.type !== AST_NODE_TYPES12.NewExpression)
     return;
-  if (element.callee.type !== AST_NODE_TYPES11.Identifier || element.callee.name !== descriptor.keypointName)
+  if (element.callee.type !== AST_NODE_TYPES12.Identifier || element.callee.name !== descriptor.keypointName)
     return;
   if (element.arguments.length !== 2)
     return;
@@ -20487,7 +21646,7 @@ var prefer_sequence_overloads_default = createRule({
         if (descriptor === undefined || node.arguments.length !== 1)
           return;
         const [argument] = node.arguments;
-        if (argument === undefined || argument.type !== AST_NODE_TYPES11.ArrayExpression || argument.elements.length !== 2)
+        if (argument === undefined || argument.type !== AST_NODE_TYPES12.ArrayExpression || argument.elements.length !== 2)
           return;
         const firstElement = argument.elements[0] ?? undefined;
         const secondElement = argument.elements[1] ?? undefined;
@@ -20677,7 +21836,7 @@ var prefer_singular_enums_default = createRule({
 });
 
 // src/rules/prefer-udim2-shorthand.ts
-import { TSESTree as TSESTree7 } from "@typescript-eslint/utils";
+import { TSESTree as TSESTree8 } from "@typescript-eslint/utils";
 function isNumber(value) {
   return typeof value === "number" && !Number.isNaN(value);
 }
@@ -20691,15 +21850,15 @@ var OPERATORS2 = new Set(["+", "-", "*", "/", "%"]);
 function reconstructText(node) {
   const nodeType = node.type;
   let text;
-  if (nodeType === TSESTree7.AST_NODE_TYPES.Literal) {
+  if (nodeType === TSESTree8.AST_NODE_TYPES.Literal) {
     const { value } = node;
     text = isNumber(value) ? String(value) : undefined;
   }
-  if (nodeType === TSESTree7.AST_NODE_TYPES.Identifier) {
+  if (nodeType === TSESTree8.AST_NODE_TYPES.Identifier) {
     const { name } = node;
     text = typeof name === "string" ? name : undefined;
   }
-  if (nodeType === TSESTree7.AST_NODE_TYPES.UnaryExpression) {
+  if (nodeType === TSESTree8.AST_NODE_TYPES.UnaryExpression) {
     const { operator } = node;
     if (typeof operator === "string") {
       const { argument } = node;
@@ -20710,7 +21869,7 @@ function reconstructText(node) {
       }
     }
   }
-  if (nodeType === TSESTree7.AST_NODE_TYPES.BinaryExpression) {
+  if (nodeType === TSESTree8.AST_NODE_TYPES.BinaryExpression) {
     const { operator } = node;
     if (typeof operator === "string" && OPERATORS2.has(operator)) {
       const { left, right } = node;
@@ -20773,11 +21932,11 @@ function evaluateExpression(node) {
   if (!isRecord3(node))
     return;
   switch (node.type) {
-    case TSESTree7.AST_NODE_TYPES.Literal:
+    case TSESTree8.AST_NODE_TYPES.Literal:
       return evaluateLiteral(node);
-    case TSESTree7.AST_NODE_TYPES.UnaryExpression:
+    case TSESTree8.AST_NODE_TYPES.UnaryExpression:
       return evaluateUnary(node);
-    case TSESTree7.AST_NODE_TYPES.BinaryExpression:
+    case TSESTree8.AST_NODE_TYPES.BinaryExpression:
       return evaluateBinary(node);
     default:
       return;
@@ -20791,7 +21950,7 @@ function collectArguments(_context2, parameters3) {
     const parameter2 = parameters3[index2];
     if (!(isRecord3(parameter2) && hasTypeProperty(parameter2)))
       return;
-    if (parameter2.type === TSESTree7.AST_NODE_TYPES.SpreadElement)
+    if (parameter2.type === TSESTree8.AST_NODE_TYPES.SpreadElement)
       return;
     const text = reconstructText(parameter2);
     if (text === undefined)
@@ -20808,7 +21967,7 @@ var preferUDim2Shorthand = {
   create(context) {
     return {
       NewExpression(node) {
-        if (node.callee.type !== TSESTree7.AST_NODE_TYPES.Identifier || node.callee.name !== "UDim2")
+        if (node.callee.type !== TSESTree8.AST_NODE_TYPES.Identifier || node.callee.name !== "UDim2")
           return;
         const collected = collectArguments(context, node.arguments);
         if (!collected)
@@ -20855,16 +22014,16 @@ var preferUDim2Shorthand = {
 var prefer_udim2_shorthand_default = preferUDim2Shorthand;
 
 // src/rules/react-hooks-strict-return.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES12 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES13 } from "@typescript-eslint/utils";
 var MAX_RETURN_ELEMENTS = 2;
 var HOOK_PATTERN = /^use[A-Z0-9].*$/;
 function isHookNode(node) {
   let name;
-  if (node.type === AST_NODE_TYPES12.VariableDeclarator && node.id.type === AST_NODE_TYPES12.Identifier) {
+  if (node.type === AST_NODE_TYPES13.VariableDeclarator && node.id.type === AST_NODE_TYPES13.Identifier) {
     ({ name } = node.id);
-  } else if (node.type === AST_NODE_TYPES12.FunctionDeclaration && node.id)
+  } else if (node.type === AST_NODE_TYPES13.FunctionDeclaration && node.id)
     ({ name } = node.id);
-  else if (node.type === AST_NODE_TYPES12.FunctionExpression && node.id)
+  else if (node.type === AST_NODE_TYPES13.FunctionExpression && node.id)
     ({ name } = node.id);
   return name !== undefined && HOOK_PATTERN.test(name);
 }
@@ -20888,27 +22047,27 @@ function getArrayElementsFromVariable(scope, name) {
     if (!identifier3.parent)
       continue;
     const { parent } = identifier3;
-    if (parent.type !== AST_NODE_TYPES12.VariableDeclarator)
+    if (parent.type !== AST_NODE_TYPES13.VariableDeclarator)
       continue;
-    if (!parent.init || parent.init.type !== AST_NODE_TYPES12.ArrayExpression)
+    if (!parent.init || parent.init.type !== AST_NODE_TYPES13.ArrayExpression)
       continue;
     elements.push(...parent.init.elements);
   }
   return elements;
 }
 function countReturnElements(argument, scope) {
-  if (argument.type === AST_NODE_TYPES12.Identifier)
+  if (argument.type === AST_NODE_TYPES13.Identifier)
     return getArrayElementsFromVariable(scope, argument.name).length;
-  if (argument.type !== AST_NODE_TYPES12.ArrayExpression)
+  if (argument.type !== AST_NODE_TYPES13.ArrayExpression)
     return 0;
   let count = 0;
   for (const element of argument.elements) {
     if (element === null)
       count += 1;
-    else if (element.type === AST_NODE_TYPES12.SpreadElement) {
-      if (element.argument.type === AST_NODE_TYPES12.Identifier) {
+    else if (element.type === AST_NODE_TYPES13.SpreadElement) {
+      if (element.argument.type === AST_NODE_TYPES13.Identifier) {
         count += getArrayElementsFromVariable(scope, element.argument.name).length;
-      } else if (element.argument.type === AST_NODE_TYPES12.ArrayExpression) {
+      } else if (element.argument.type === AST_NODE_TYPES13.ArrayExpression) {
         count += element.argument.elements.length;
       } else
         count += 1;
@@ -20921,14 +22080,14 @@ function exceedsMaxReturnProperties(node, scope) {
   const { argument } = node;
   if (argument === null)
     return false;
-  if (argument.type === AST_NODE_TYPES12.ObjectExpression)
+  if (argument.type === AST_NODE_TYPES13.ObjectExpression)
     return false;
-  if (argument.type === AST_NODE_TYPES12.Identifier) {
+  if (argument.type === AST_NODE_TYPES13.Identifier) {
     const variable = getVariableByName(scope, argument.name);
     if (variable) {
       for (const { identifier: identifier3 } of variable.references) {
         const { parent } = identifier3;
-        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.init?.type === AST_NODE_TYPES12.ObjectExpression) {
+        if (parent?.type === AST_NODE_TYPES13.VariableDeclarator && parent.init?.type === AST_NODE_TYPES13.ObjectExpression) {
           return false;
         }
       }
@@ -20950,13 +22109,13 @@ var react_hooks_strict_return_default = createRule({
     return {
       ArrowFunctionExpression(node) {
         const { parent } = node;
-        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.id.type === AST_NODE_TYPES12.Identifier && HOOK_PATTERN.test(parent.id.name)) {
+        if (parent?.type === AST_NODE_TYPES13.VariableDeclarator && parent.id.type === AST_NODE_TYPES13.Identifier && HOOK_PATTERN.test(parent.id.name)) {
           hookDepth += 1;
         }
       },
       "ArrowFunctionExpression:exit"(node) {
         const { parent } = node;
-        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.id.type === AST_NODE_TYPES12.Identifier && HOOK_PATTERN.test(parent.id.name)) {
+        if (parent?.type === AST_NODE_TYPES13.VariableDeclarator && parent.id.type === AST_NODE_TYPES13.Identifier && HOOK_PATTERN.test(parent.id.name)) {
           hookDepth -= 1;
         }
       },
@@ -20994,13 +22153,17 @@ var react_hooks_strict_return_default = createRule({
 });
 
 // src/rules/require-named-effect-functions.ts
-import { TSESTree as TSESTree8 } from "@typescript-eslint/types";
+import { TSESTree as TSESTree9 } from "@typescript-eslint/types";
+
+// src/types/environment-mode.ts
+var isEnvironmentMode = build_default.Union([build_default.Literal("roblox-ts"), build_default.Literal("standard")]);
+
+// src/rules/require-named-effect-functions.ts
 var DEFAULT_HOOKS = [
   { allowAsync: false, name: "useEffect" },
   { allowAsync: false, name: "useLayoutEffect" },
   { allowAsync: false, name: "useInsertionEffect" }
 ];
-var isEnvironmentMode = build_default.Union([build_default.Literal("roblox-ts"), build_default.Literal("standard")]);
 var isHookConfiguration = build_default.Object({
   allowAsync: build_default.Boolean(),
   name: build_default.String()
@@ -21029,10 +22192,10 @@ function parseOptions2(options3) {
 }
 function getHookName3(callExpression) {
   const { callee } = callExpression;
-  if (callee.type === TSESTree8.AST_NODE_TYPES.Identifier && typeof callee.name === "string" && callee.name.length > 0) {
+  if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier && typeof callee.name === "string" && callee.name.length > 0) {
     return callee.name;
   }
-  if (callee.type === TSESTree8.AST_NODE_TYPES.MemberExpression && callee.property?.type === TSESTree8.AST_NODE_TYPES.Identifier && typeof callee.property.name === "string" && callee.property.name.length > 0) {
+  if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.property?.type === TSESTree9.AST_NODE_TYPES.Identifier && typeof callee.property.name === "string" && callee.property.name.length > 0) {
     return callee.property.name;
   }
   return;
@@ -21075,14 +22238,14 @@ function processFunctionExpression(init) {
 }
 function checkVariableDeclaratorDef(node) {
   const castNode = node;
-  if (castNode.type !== TSESTree8.AST_NODE_TYPES.VariableDeclarator)
+  if (castNode.type !== TSESTree9.AST_NODE_TYPES.VariableDeclarator)
     return;
   if (typeof castNode.init !== "object" || castNode.init === null)
     return;
   const castInit = castNode.init;
-  if (castInit.type === TSESTree8.AST_NODE_TYPES.ArrowFunctionExpression)
+  if (castInit.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression)
     return processArrowFunction(castNode.init);
-  if (castInit.type === TSESTree8.AST_NODE_TYPES.FunctionExpression)
+  if (castInit.type === TSESTree9.AST_NODE_TYPES.FunctionExpression)
     return processFunctionExpression(castNode.init);
   return;
 }
@@ -21094,7 +22257,7 @@ function processSingleDefinition(definition) {
   if (typeof node !== "object" || node === null)
     return;
   const castNode = node;
-  if (castNode.type === TSESTree8.AST_NODE_TYPES.FunctionDeclaration)
+  if (castNode.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration)
     return processFunctionDeclaration(node);
   return checkVariableDeclaratorDef(node);
 }
@@ -21154,12 +22317,12 @@ function isCallbackHookResult(identifier3, context) {
       if (typeof node !== "object" || node === null)
         continue;
       const castNode = node;
-      if (castNode.type !== TSESTree8.AST_NODE_TYPES.VariableDeclarator)
+      if (castNode.type !== TSESTree9.AST_NODE_TYPES.VariableDeclarator)
         continue;
       if (typeof castNode.init !== "object" || castNode.init === null)
         continue;
       const init = castNode.init;
-      if (init.type !== TSESTree8.AST_NODE_TYPES.CallExpression)
+      if (init.type !== TSESTree9.AST_NODE_TYPES.CallExpression)
         continue;
       const calleeHookName = getHookName3(init);
       if (calleeHookName === "useCallback" || calleeHookName === "useMemo")
@@ -21190,7 +22353,7 @@ var requireNamedEffectFunctions = {
         if (firstArgument === undefined)
           return;
         const argumentNode = firstArgument;
-        if (argumentNode.type === TSESTree8.AST_NODE_TYPES.Identifier) {
+        if (argumentNode.type === TSESTree9.AST_NODE_TYPES.Identifier) {
           const identifier3 = argumentNode;
           const resolved = resolveIdentifierToFunction(identifier3, context);
           if (resolved === undefined) {
@@ -21243,7 +22406,7 @@ var requireNamedEffectFunctions = {
           }
           return;
         }
-        if (argumentNode.type === TSESTree8.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (argumentNode.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression) {
           if (argumentNode.async) {
             context.report({
               data: { hook: hookName },
@@ -21259,7 +22422,7 @@ var requireNamedEffectFunctions = {
           }
           return;
         }
-        if (argumentNode.type === TSESTree8.AST_NODE_TYPES.FunctionExpression) {
+        if (argumentNode.type === TSESTree9.AST_NODE_TYPES.FunctionExpression) {
           const functionHasId = Boolean(argumentNode.id);
           if (functionHasId && argumentNode.async) {
             context.report({
@@ -21348,7 +22511,7 @@ var requireNamedEffectFunctions = {
 var require_named_effect_functions_default = requireNamedEffectFunctions;
 
 // src/rules/require-paired-calls.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES13 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES14 } from "@typescript-eslint/types";
 var isStringArray = Compile(build_default.Readonly(build_default.Array(build_default.String())));
 var isPairConfiguration = Compile(build_default.Readonly(build_default.Object({
   alternatives: build_default.Optional(isStringArray),
@@ -21366,20 +22529,20 @@ var isRuleOptions4 = Compile(build_default.Partial(build_default.Readonly(build_
   pairs: build_default.Readonly(build_default.Array(isPairConfiguration))
 }))));
 var LOOP_NODE_TYPES = new Set([
-  AST_NODE_TYPES13.DoWhileStatement,
-  AST_NODE_TYPES13.ForInStatement,
-  AST_NODE_TYPES13.ForOfStatement,
-  AST_NODE_TYPES13.ForStatement,
-  AST_NODE_TYPES13.WhileStatement
+  AST_NODE_TYPES14.DoWhileStatement,
+  AST_NODE_TYPES14.ForInStatement,
+  AST_NODE_TYPES14.ForOfStatement,
+  AST_NODE_TYPES14.ForStatement,
+  AST_NODE_TYPES14.WhileStatement
 ]);
 var DEFAULT_ROBLOX_YIELDING_FUNCTIONS = ["task.wait", "wait", "*.WaitForChild", "*.*Async"];
 function getCallName(node) {
   const { callee } = node;
-  if (callee.type === AST_NODE_TYPES13.Identifier)
+  if (callee.type === AST_NODE_TYPES14.Identifier)
     return callee.name;
-  if (callee.type === AST_NODE_TYPES13.MemberExpression) {
-    const object3 = callee.object.type === AST_NODE_TYPES13.Identifier ? callee.object.name : undefined;
-    const property = callee.property.type === AST_NODE_TYPES13.Identifier ? callee.property.name : undefined;
+  if (callee.type === AST_NODE_TYPES14.MemberExpression) {
+    const object3 = callee.object.type === AST_NODE_TYPES14.Identifier ? callee.object.name : undefined;
+    const property = callee.property.type === AST_NODE_TYPES14.Identifier ? callee.property.name : undefined;
     if (object3 !== undefined && property !== undefined)
       return `${object3}.${property}`;
   }
@@ -21415,12 +22578,12 @@ function isLoopLikeStatement(node) {
   return LOOP_NODE_TYPES.has(node.type);
 }
 function isSwitchStatement(node) {
-  return node?.type === AST_NODE_TYPES13.SwitchStatement;
+  return node?.type === AST_NODE_TYPES14.SwitchStatement;
 }
 function findLabeledStatementBody(label, startingNode) {
   let current = startingNode;
   while (current) {
-    if (current.type === AST_NODE_TYPES13.LabeledStatement && current.label.name === label.name)
+    if (current.type === AST_NODE_TYPES14.LabeledStatement && current.label.name === label.name)
       return current.body;
     current = current.parent ?? undefined;
   }
@@ -21682,7 +22845,7 @@ var rule = {
     function onIfConsequentExit(node) {
       const consequentNode = node;
       const { parent } = consequentNode;
-      if (parent?.type === AST_NODE_TYPES13.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES14.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21697,7 +22860,7 @@ var rule = {
     function onIfAlternateExit(node) {
       const alternateNode = node;
       const { parent } = alternateNode;
-      if (parent?.type === AST_NODE_TYPES13.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES14.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21746,7 +22909,7 @@ var rule = {
     function onTryBlockExit(node) {
       const blockNode = node;
       const { parent } = blockNode;
-      if (parent?.type === AST_NODE_TYPES13.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES14.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21765,7 +22928,7 @@ var rule = {
     function onCatchClauseExit(node) {
       const catchNode = node;
       const { parent } = catchNode;
-      if (parent?.type === AST_NODE_TYPES13.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES14.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21828,7 +22991,7 @@ var rule = {
     function onSwitchCaseExit(node) {
       const caseNode = node;
       const { parent } = caseNode;
-      if (parent?.type === AST_NODE_TYPES13.SwitchStatement) {
+      if (parent?.type === AST_NODE_TYPES14.SwitchStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21859,7 +23022,7 @@ var rule = {
       for (const { opener, config, node: node2 } of openerStack) {
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES13.ReturnStatement ? "return" : "throw";
+        const statementType = statementNode.type === AST_NODE_TYPES14.ReturnStatement ? "return" : "throw";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -21876,7 +23039,7 @@ var rule = {
       const statementNode = node;
       if (openerStack.length === 0)
         return;
-      const targetLoop = statementNode.type === AST_NODE_TYPES13.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
+      const targetLoop = statementNode.type === AST_NODE_TYPES14.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
       if (!targetLoop)
         return;
       for (const { node: openerNode, config, opener, loopAncestors } of openerStack) {
@@ -21884,7 +23047,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES13.BreakStatement ? "break" : "continue";
+        const statementType = statementNode.type === AST_NODE_TYPES14.BreakStatement ? "break" : "continue";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -22022,7 +23185,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const asyncType = asyncNode.type === AST_NODE_TYPES13.AwaitExpression ? "await" : "yield";
+        const asyncType = asyncNode.type === AST_NODE_TYPES14.AwaitExpression ? "await" : "yield";
         context.report({
           data: { asyncType, closer, opener },
           messageId: "asyncViolation",
@@ -22157,8 +23320,8 @@ var rule = {
 var require_paired_calls_default = rule;
 
 // src/rules/require-react-component-keys.ts
-import { TSESTree as TSESTree9 } from "@typescript-eslint/types";
-var DEFAULT_OPTIONS3 = {
+import { TSESTree as TSESTree10 } from "@typescript-eslint/types";
+var DEFAULT_OPTIONS4 = {
   allowRootKeys: false,
   ignoreCallExpressions: ["ReactTree.mount", "CreateReactStory"],
   iterationMethods: [
@@ -22200,17 +23363,17 @@ function ascendPastWrappers(node) {
 }
 function hasKeyAttribute(node) {
   for (const attribute of node.openingElement.attributes) {
-    if (attribute.type === TSESTree9.AST_NODE_TYPES.JSXAttribute && attribute.name.name === "key")
+    if (attribute.type === TSESTree10.AST_NODE_TYPES.JSXAttribute && attribute.name.name === "key")
       return true;
   }
   return false;
 }
 function isHigherOrderComponent(callExpr) {
   const { callee } = callExpr;
-  if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier) {
     return callee.name === "forwardRef" || callee.name === "memo";
   }
-  if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
     return callee.property.name === "forwardRef" || callee.property.name === "memo";
   }
   return false;
@@ -22218,7 +23381,7 @@ function isHigherOrderComponent(callExpr) {
 function getEnclosingFunctionLike(node) {
   let current = node.parent;
   while (current) {
-    if (current.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression || current.type === TSESTree9.AST_NODE_TYPES.FunctionExpression || current.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration) {
+    if (current.type === TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression || current.type === TSESTree10.AST_NODE_TYPES.FunctionExpression || current.type === TSESTree10.AST_NODE_TYPES.FunctionDeclaration) {
       return current;
     }
     current = current.parent;
@@ -22227,16 +23390,16 @@ function getEnclosingFunctionLike(node) {
 }
 function isIterationOrMemoCallback(callExpression, iterationMethods, memoizationHooks) {
   const { callee } = callExpression;
-  if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier && memoizationHooks.has(callee.name))
+  if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier && memoizationHooks.has(callee.name))
     return true;
-  if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
     const { name } = callee.property;
     if (iterationMethods.has(name))
       return true;
-    if (name === "from" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.object.name === "Array" && callExpression.arguments.length >= 2) {
+    if (name === "from" && callee.object.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.object.object.name === "Array" && callExpression.arguments.length >= 2) {
       return true;
     }
-    if (name === "call" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.property.type === TSESTree9.AST_NODE_TYPES.Identifier && iterationMethods.has(callee.object.object.property.name)) {
+    if (name === "call" && callee.object.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.object.property.type === TSESTree10.AST_NODE_TYPES.Identifier && iterationMethods.has(callee.object.object.property.name)) {
       return true;
     }
   }
@@ -22246,11 +23409,11 @@ function findEnclosingCallExpression(node) {
   let current = node;
   let { parent } = node;
   while (parent) {
-    if (parent.type === TSESTree9.AST_NODE_TYPES.CallExpression) {
+    if (parent.type === TSESTree10.AST_NODE_TYPES.CallExpression) {
       for (const argument of parent.arguments) {
         if (argument === current)
           return parent;
-        if (argument.type === TSESTree9.AST_NODE_TYPES.SpreadElement && argument.argument === current) {
+        if (argument.type === TSESTree10.AST_NODE_TYPES.SpreadElement && argument.argument === current) {
           return parent;
         }
       }
@@ -22266,7 +23429,7 @@ function findEnclosingCallExpression(node) {
   return;
 }
 function getVariableForFunction(context, functionLike) {
-  if (functionLike.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration) {
+  if (functionLike.type === TSESTree10.AST_NODE_TYPES.FunctionDeclaration) {
     const declared = context.sourceCode.getDeclaredVariables(functionLike);
     if (declared.length > 0)
       return declared[0];
@@ -22275,7 +23438,7 @@ function getVariableForFunction(context, functionLike) {
   const { parent } = functionLike;
   if (!parent)
     return;
-  if (parent.type === TSESTree9.AST_NODE_TYPES.VariableDeclarator || parent.type === TSESTree9.AST_NODE_TYPES.AssignmentExpression) {
+  if (parent.type === TSESTree10.AST_NODE_TYPES.VariableDeclarator || parent.type === TSESTree10.AST_NODE_TYPES.AssignmentExpression) {
     const declared = context.sourceCode.getDeclaredVariables(parent);
     if (declared.length > 0)
       return declared[0];
@@ -22309,33 +23472,33 @@ function isFunctionUsedAsCallback(context, functionLike, iterationMethods, memoi
   return false;
 }
 var SHOULD_ASCEND_TYPES = new Set([
-  TSESTree9.AST_NODE_TYPES.ConditionalExpression,
-  TSESTree9.AST_NODE_TYPES.LogicalExpression
+  TSESTree10.AST_NODE_TYPES.ConditionalExpression,
+  TSESTree10.AST_NODE_TYPES.LogicalExpression
 ]);
 var IS_FUNCTION_EXPRESSION = new Set([
-  TSESTree9.AST_NODE_TYPES.FunctionExpression,
-  TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression
+  TSESTree10.AST_NODE_TYPES.FunctionExpression,
+  TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var CONTROL_FLOW_TYPES = new Set([
-  TSESTree9.AST_NODE_TYPES.BlockStatement,
-  TSESTree9.AST_NODE_TYPES.IfStatement,
-  TSESTree9.AST_NODE_TYPES.SwitchStatement,
-  TSESTree9.AST_NODE_TYPES.SwitchCase,
-  TSESTree9.AST_NODE_TYPES.TryStatement,
-  TSESTree9.AST_NODE_TYPES.CatchClause,
-  TSESTree9.AST_NODE_TYPES.WhileStatement,
-  TSESTree9.AST_NODE_TYPES.DoWhileStatement,
-  TSESTree9.AST_NODE_TYPES.ForStatement,
-  TSESTree9.AST_NODE_TYPES.ForInStatement,
-  TSESTree9.AST_NODE_TYPES.ForOfStatement,
-  TSESTree9.AST_NODE_TYPES.LabeledStatement,
-  TSESTree9.AST_NODE_TYPES.WithStatement
+  TSESTree10.AST_NODE_TYPES.BlockStatement,
+  TSESTree10.AST_NODE_TYPES.IfStatement,
+  TSESTree10.AST_NODE_TYPES.SwitchStatement,
+  TSESTree10.AST_NODE_TYPES.SwitchCase,
+  TSESTree10.AST_NODE_TYPES.TryStatement,
+  TSESTree10.AST_NODE_TYPES.CatchClause,
+  TSESTree10.AST_NODE_TYPES.WhileStatement,
+  TSESTree10.AST_NODE_TYPES.DoWhileStatement,
+  TSESTree10.AST_NODE_TYPES.ForStatement,
+  TSESTree10.AST_NODE_TYPES.ForInStatement,
+  TSESTree10.AST_NODE_TYPES.ForOfStatement,
+  TSESTree10.AST_NODE_TYPES.LabeledStatement,
+  TSESTree10.AST_NODE_TYPES.WithStatement
 ]);
 function isTopLevelReturn(node) {
   let parent = ascendPastWrappers(node.parent);
   if (!parent)
     return false;
-  if (parent.type === TSESTree9.AST_NODE_TYPES.JSXExpressionContainer)
+  if (parent.type === TSESTree10.AST_NODE_TYPES.JSXExpressionContainer)
     parent = ascendPastWrappers(parent.parent);
   if (!parent)
     return false;
@@ -22343,11 +23506,11 @@ function isTopLevelReturn(node) {
     parent = ascendPastWrappers(parent.parent);
   if (!parent)
     return false;
-  if (parent.type === TSESTree9.AST_NODE_TYPES.JSXExpressionContainer)
+  if (parent.type === TSESTree10.AST_NODE_TYPES.JSXExpressionContainer)
     parent = ascendPastWrappers(parent.parent);
   if (!parent)
     return false;
-  if (parent.type === TSESTree9.AST_NODE_TYPES.ReturnStatement) {
+  if (parent.type === TSESTree10.AST_NODE_TYPES.ReturnStatement) {
     let currentNode = ascendPastWrappers(parent.parent);
     while (currentNode && CONTROL_FLOW_TYPES.has(currentNode.type)) {
       currentNode = ascendPastWrappers(currentNode.parent);
@@ -22356,16 +23519,16 @@ function isTopLevelReturn(node) {
       return false;
     if (IS_FUNCTION_EXPRESSION.has(currentNode.type)) {
       const functionParent = ascendPastWrappers(currentNode.parent);
-      if (functionParent?.type === TSESTree9.AST_NODE_TYPES.CallExpression) {
+      if (functionParent?.type === TSESTree10.AST_NODE_TYPES.CallExpression) {
         return isHigherOrderComponent(functionParent);
       }
       return true;
     }
-    return currentNode.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration;
+    return currentNode.type === TSESTree10.AST_NODE_TYPES.FunctionDeclaration;
   }
-  if (parent.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression) {
+  if (parent.type === TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression) {
     const functionParent = ascendPastWrappers(parent.parent);
-    if (functionParent?.type === TSESTree9.AST_NODE_TYPES.CallExpression) {
+    if (functionParent?.type === TSESTree10.AST_NODE_TYPES.CallExpression) {
       return isHigherOrderComponent(functionParent);
     }
     return true;
@@ -22376,7 +23539,7 @@ function isIgnoredCallExpression(node, ignoreList) {
   let parent = node.parent;
   if (!parent)
     return false;
-  if (parent.type === TSESTree9.AST_NODE_TYPES.JSXExpressionContainer) {
+  if (parent.type === TSESTree10.AST_NODE_TYPES.JSXExpressionContainer) {
     ({ parent } = parent);
     if (!parent)
       return false;
@@ -22384,11 +23547,11 @@ function isIgnoredCallExpression(node, ignoreList) {
   const maxDepth = 20;
   for (let depth = 0;depth < maxDepth && parent; depth += 1) {
     const { type: type3 } = parent;
-    if (type3 === TSESTree9.AST_NODE_TYPES.CallExpression) {
+    if (type3 === TSESTree10.AST_NODE_TYPES.CallExpression) {
       const { callee } = parent;
-      if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier)
+      if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier)
         return ignoreList.includes(callee.name);
-      if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier) {
+      if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
         return ignoreList.includes(`${callee.object.name}.${callee.property.name}`);
       }
       return false;
@@ -22401,41 +23564,41 @@ function isJSXPropValue(node) {
   let { parent } = node;
   if (!parent)
     return false;
-  while (parent && (parent.type === TSESTree9.AST_NODE_TYPES.ConditionalExpression || parent.type === TSESTree9.AST_NODE_TYPES.LogicalExpression)) {
+  while (parent && (parent.type === TSESTree10.AST_NODE_TYPES.ConditionalExpression || parent.type === TSESTree10.AST_NODE_TYPES.LogicalExpression)) {
     ({ parent } = parent);
   }
   if (!parent)
     return false;
-  if (parent.type === TSESTree9.AST_NODE_TYPES.JSXExpressionContainer) {
+  if (parent.type === TSESTree10.AST_NODE_TYPES.JSXExpressionContainer) {
     ({ parent } = parent);
     if (!parent)
       return false;
   }
-  return parent.type === TSESTree9.AST_NODE_TYPES.JSXAttribute;
+  return parent.type === TSESTree10.AST_NODE_TYPES.JSXAttribute;
 }
 function isTernaryJSXChild(node) {
   let current = node.parent;
   if (!current)
     return false;
   let foundTernary = false;
-  while (current && (current.type === TSESTree9.AST_NODE_TYPES.ConditionalExpression || WRAPPER_PARENT_TYPES.has(current.type))) {
-    if (current.type === TSESTree9.AST_NODE_TYPES.ConditionalExpression)
+  while (current && (current.type === TSESTree10.AST_NODE_TYPES.ConditionalExpression || WRAPPER_PARENT_TYPES.has(current.type))) {
+    if (current.type === TSESTree10.AST_NODE_TYPES.ConditionalExpression)
       foundTernary = true;
     current = current.parent;
   }
   if (!(foundTernary && current))
     return false;
-  if (current.type !== TSESTree9.AST_NODE_TYPES.JSXExpressionContainer)
+  if (current.type !== TSESTree10.AST_NODE_TYPES.JSXExpressionContainer)
     return false;
   const containerParent = current.parent;
   if (!containerParent)
     return false;
-  return containerParent.type === TSESTree9.AST_NODE_TYPES.JSXElement || containerParent.type === TSESTree9.AST_NODE_TYPES.JSXFragment;
+  return containerParent.type === TSESTree10.AST_NODE_TYPES.JSXElement || containerParent.type === TSESTree10.AST_NODE_TYPES.JSXFragment;
 }
 var require_react_component_keys_default = createRule({
   create(context) {
     const options3 = {
-      ...DEFAULT_OPTIONS3,
+      ...DEFAULT_OPTIONS4,
       ...context.options[0]
     };
     const iterationMethods = new Set(options3.iterationMethods);
@@ -22445,7 +23608,7 @@ var require_react_component_keys_default = createRule({
       const isCallback = functionLike ? isFunctionUsedAsCallback(context, functionLike, iterationMethods, memoizationHooks) : false;
       const isRoot = isTopLevelReturn(node);
       if (isRoot && !isCallback) {
-        if (!options3.allowRootKeys && node.type === TSESTree9.AST_NODE_TYPES.JSXElement && hasKeyAttribute(node)) {
+        if (!options3.allowRootKeys && node.type === TSESTree10.AST_NODE_TYPES.JSXElement && hasKeyAttribute(node)) {
           context.report({
             messageId: "rootComponentWithKey",
             node
@@ -22459,7 +23622,7 @@ var require_react_component_keys_default = createRule({
         return;
       if (isTernaryJSXChild(node))
         return;
-      if (node.type === TSESTree9.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === TSESTree10.AST_NODE_TYPES.JSXFragment) {
         context.report({
           messageId: "missingKey",
           node
@@ -22482,7 +23645,7 @@ var require_react_component_keys_default = createRule({
       }
     };
   },
-  defaultOptions: [DEFAULT_OPTIONS3],
+  defaultOptions: [DEFAULT_OPTIONS4],
   meta: {
     docs: {
       description: "Require keys on React components when used in lists or iteration."
@@ -22539,38 +23702,30 @@ var require_react_component_keys_default = createRule({
 });
 
 // src/rules/require-react-display-names.ts
-import { TSESTree as TSESTree10 } from "@typescript-eslint/types";
-var DEFAULT_OPTIONS4 = {
+import { TSESTree as TSESTree11 } from "@typescript-eslint/types";
+var DEFAULT_OPTIONS5 = {
   environment: "roblox-ts"
 };
-var REACT_SOURCES_ROBLOX = new Set(["@rbxts/react", "@rbxts/roact"]);
-var REACT_SOURCES_STANDARD = new Set(["react", "react-dom"]);
-function getReactSources(environment2) {
-  return environment2 === "roblox-ts" ? REACT_SOURCES_ROBLOX : REACT_SOURCES_STANDARD;
-}
-function isReactImport(node, reactSources) {
-  return reactSources.has(node.source.value);
-}
-function isMemoCall(node, memoIdentifiers, reactNamespaces) {
+function isMemoCall2(node, memoIdentifiers, reactNamespaces) {
   const { callee } = node;
-  if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree11.AST_NODE_TYPES.Identifier)
     return memoIdentifiers.has(callee.name);
-  if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier) {
     return reactNamespaces.has(callee.object.name) && callee.property.name === "memo";
   }
   return false;
 }
 function isCreateContextCall(node, createContextIdentifiers, reactNamespaces) {
   const { callee } = node;
-  if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree11.AST_NODE_TYPES.Identifier)
     return createContextIdentifiers.has(callee.name);
-  if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier) {
     return reactNamespaces.has(callee.object.name) && callee.property.name === "createContext";
   }
   return false;
 }
 function getVariableName(node) {
-  if (node.id.type === TSESTree10.AST_NODE_TYPES.Identifier)
+  if (node.id.type === TSESTree11.AST_NODE_TYPES.Identifier)
     return node.id.name;
   return;
 }
@@ -22578,9 +23733,9 @@ function isNodeInExport(node) {
   let current = node;
   while (current) {
     const { type: type3 } = current;
-    if (type3 === TSESTree10.AST_NODE_TYPES.ExportNamedDeclaration)
+    if (type3 === TSESTree11.AST_NODE_TYPES.ExportNamedDeclaration)
       return true;
-    if (type3 === TSESTree10.AST_NODE_TYPES.ExportDefaultDeclaration)
+    if (type3 === TSESTree11.AST_NODE_TYPES.ExportDefaultDeclaration)
       return true;
     current = current.parent;
   }
@@ -22592,7 +23747,7 @@ function isReferenceExported(reference) {
 var require_react_display_names_default = createRule({
   create(context) {
     const options3 = {
-      ...DEFAULT_OPTIONS4,
+      ...DEFAULT_OPTIONS5,
       ...context.options[0]
     };
     const reactSources = getReactSources(options3.environment);
@@ -22604,14 +23759,14 @@ var require_react_display_names_default = createRule({
     return {
       "AssignmentExpression[left.type='MemberExpression'][left.property.name='displayName']"(node) {
         const left = node.left;
-        if (left.object.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+        if (left.object.type === TSESTree11.AST_NODE_TYPES.Identifier) {
           displayNameAssignments.add(left.object.name);
         }
       },
       ExportDefaultDeclaration(node) {
         const { declaration } = node;
-        if (declaration.type === TSESTree10.AST_NODE_TYPES.CallExpression) {
-          if (isMemoCall(declaration, memoIdentifiers, reactNamespaces)) {
+        if (declaration.type === TSESTree11.AST_NODE_TYPES.CallExpression) {
+          if (isMemoCall2(declaration, memoIdentifiers, reactNamespaces)) {
             context.report({
               messageId: "directMemoExport",
               node
@@ -22626,7 +23781,7 @@ var require_react_display_names_default = createRule({
             return;
           }
         }
-        if (declaration.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+        if (declaration.type === TSESTree11.AST_NODE_TYPES.Identifier) {
           const tracked = trackedVariables.get(declaration.name);
           if (tracked) {
             trackedVariables.set(declaration.name, {
@@ -22640,10 +23795,10 @@ var require_react_display_names_default = createRule({
         if (!node.specifiers)
           return;
         for (const specifier of node.specifiers) {
-          if (specifier.type !== TSESTree10.AST_NODE_TYPES.ExportSpecifier)
+          if (specifier.type !== TSESTree11.AST_NODE_TYPES.ExportSpecifier)
             continue;
-          const localName = specifier.local.type === TSESTree10.AST_NODE_TYPES.Identifier ? specifier.local.name : specifier.local.value;
-          const exportedName = specifier.exported.type === TSESTree10.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+          const localName = specifier.local.type === TSESTree11.AST_NODE_TYPES.Identifier ? specifier.local.name : specifier.local.value;
+          const exportedName = specifier.exported.type === TSESTree11.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
           if (exportedName === "default") {
             const tracked = trackedVariables.get(localName);
             if (tracked) {
@@ -22659,10 +23814,10 @@ var require_react_display_names_default = createRule({
         if (!isReactImport(node, reactSources))
           return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === TSESTree10.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === TSESTree10.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+          if (specifier.type === TSESTree11.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === TSESTree11.AST_NODE_TYPES.ImportNamespaceSpecifier) {
             reactNamespaces.add(specifier.local.name);
-          } else if (specifier.type === TSESTree10.AST_NODE_TYPES.ImportSpecifier) {
-            const importedName = specifier.imported.type === TSESTree10.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+          } else if (specifier.type === TSESTree11.AST_NODE_TYPES.ImportSpecifier) {
+            const importedName = specifier.imported.type === TSESTree11.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
             if (importedName === "memo")
               memoIdentifiers.add(specifier.local.name);
             else if (importedName === "createContext")
@@ -22681,7 +23836,7 @@ var require_react_display_names_default = createRule({
           if (variable)
             isExported ||= variable.references.some(isReferenceExported);
           const declarationParent = tracked.node.parent;
-          if (declarationParent?.parent?.type === TSESTree10.AST_NODE_TYPES.ExportNamedDeclaration) {
+          if (declarationParent?.parent?.type === TSESTree11.AST_NODE_TYPES.ExportNamedDeclaration) {
             isExported = true;
           }
           if (isExported) {
@@ -22694,12 +23849,12 @@ var require_react_display_names_default = createRule({
         }
       },
       VariableDeclarator(node) {
-        if (!node.init || node.init.type !== TSESTree10.AST_NODE_TYPES.CallExpression)
+        if (!node.init || node.init.type !== TSESTree11.AST_NODE_TYPES.CallExpression)
           return;
         const name = getVariableName(node);
         if (!name)
           return;
-        if (isMemoCall(node.init, memoIdentifiers, reactNamespaces)) {
+        if (isMemoCall2(node.init, memoIdentifiers, reactNamespaces)) {
           trackedVariables.set(name, {
             hasDisplayName: false,
             isDefaultExported: false,
@@ -22719,7 +23874,7 @@ var require_react_display_names_default = createRule({
       }
     };
   },
-  defaultOptions: [DEFAULT_OPTIONS4],
+  defaultOptions: [DEFAULT_OPTIONS5],
   meta: {
     docs: {
       description: "Require displayName property on exported React.memo components and React.createContext contexts for better debugging."
@@ -22860,16 +24015,16 @@ var strict_component_boundaries_default = createRule({
 });
 
 // src/rules/use-exhaustive-dependencies.ts
-import { TSESTree as TSESTree11 } from "@typescript-eslint/types";
+import { TSESTree as TSESTree12 } from "@typescript-eslint/types";
 var FUNCTION_DECLARATIONS = new Set([
-  TSESTree11.AST_NODE_TYPES.FunctionExpression,
-  TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression,
-  TSESTree11.AST_NODE_TYPES.FunctionDeclaration
+  TSESTree12.AST_NODE_TYPES.FunctionExpression,
+  TSESTree12.AST_NODE_TYPES.ArrowFunctionExpression,
+  TSESTree12.AST_NODE_TYPES.FunctionDeclaration
 ]);
 var UNSTABLE_VALUES = new Set([
   ...FUNCTION_DECLARATIONS,
-  TSESTree11.AST_NODE_TYPES.ObjectExpression,
-  TSESTree11.AST_NODE_TYPES.ArrayExpression
+  TSESTree12.AST_NODE_TYPES.ObjectExpression,
+  TSESTree12.AST_NODE_TYPES.ArrayExpression
 ]);
 var testingMetrics = {
   moduleLevelStableConst: 0,
@@ -22953,9 +24108,9 @@ var GLOBAL_BUILTINS = new Set([
 ]);
 function getHookName4(node) {
   const { callee } = node;
-  if (callee.type === TSESTree11.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree12.AST_NODE_TYPES.Identifier)
     return callee.name;
-  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree12.AST_NODE_TYPES.Identifier) {
     return callee.property.name;
   }
   return;
@@ -22963,9 +24118,9 @@ function getHookName4(node) {
 function getMemberExpressionDepth(node) {
   let depth = 0;
   let current = node;
-  if (current.type === TSESTree11.AST_NODE_TYPES.ChainExpression)
+  if (current.type === TSESTree12.AST_NODE_TYPES.ChainExpression)
     current = current.expression;
-  while (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === TSESTree12.AST_NODE_TYPES.MemberExpression) {
     depth += 1;
     current = current.object;
   }
@@ -22973,36 +24128,36 @@ function getMemberExpressionDepth(node) {
 }
 function getRootIdentifier(node) {
   let current = node;
-  if (current.type === TSESTree11.AST_NODE_TYPES.ChainExpression)
+  if (current.type === TSESTree12.AST_NODE_TYPES.ChainExpression)
     current = current.expression;
-  while (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression || current.type === TSESTree11.AST_NODE_TYPES.TSNonNullExpression) {
-    if (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression)
+  while (current.type === TSESTree12.AST_NODE_TYPES.MemberExpression || current.type === TSESTree12.AST_NODE_TYPES.TSNonNullExpression) {
+    if (current.type === TSESTree12.AST_NODE_TYPES.MemberExpression)
       current = current.object;
     else
       current = current.expression;
   }
-  return current.type === TSESTree11.AST_NODE_TYPES.Identifier ? current : undefined;
+  return current.type === TSESTree12.AST_NODE_TYPES.Identifier ? current : undefined;
 }
 function nodeToDependencyString(node, sourceCode) {
   return sourceCode.getText(node);
 }
 function nodeToSafeDependencyPath(node, sourceCode) {
-  if (node.type === TSESTree11.AST_NODE_TYPES.Identifier)
+  if (node.type === TSESTree12.AST_NODE_TYPES.Identifier)
     return node.name;
-  if (node.type === TSESTree11.AST_NODE_TYPES.ChainExpression) {
+  if (node.type === TSESTree12.AST_NODE_TYPES.ChainExpression) {
     return nodeToSafeDependencyPath(node.expression, sourceCode);
   }
   if (TS_RUNTIME_EXPRESSIONS.has(node.type)) {
     const expr = node;
     return nodeToSafeDependencyPath(expr.expression, sourceCode);
   }
-  if (node.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
+  if (node.type === TSESTree12.AST_NODE_TYPES.MemberExpression) {
     const objectPath = nodeToSafeDependencyPath(node.object, sourceCode);
     if (node.computed) {
       const propertyText = sourceCode.getText(node.property);
       return `${objectPath}[${propertyText}]`;
     }
-    const propertyName = node.property.type === TSESTree11.AST_NODE_TYPES.Identifier ? node.property.name : "";
+    const propertyName = node.property.type === TSESTree12.AST_NODE_TYPES.Identifier ? node.property.name : "";
     const separator = node.optional ? "?." : ".";
     return `${objectPath}${separator}${propertyName}`;
   }
@@ -23011,13 +24166,13 @@ function nodeToSafeDependencyPath(node, sourceCode) {
 function isStableArrayIndex(stableResult, node, identifierName) {
   if (!stableResult)
     return false;
-  if (!(stableResult instanceof Set) || node.type !== TSESTree11.AST_NODE_TYPES.VariableDeclarator || node.id.type !== TSESTree11.AST_NODE_TYPES.ArrayPattern) {
+  if (!(stableResult instanceof Set) || node.type !== TSESTree12.AST_NODE_TYPES.VariableDeclarator || node.id.type !== TSESTree12.AST_NODE_TYPES.ArrayPattern) {
     return false;
   }
   const { elements } = node.id;
   let index2 = 0;
   for (const element of elements) {
-    if (element.type === TSESTree11.AST_NODE_TYPES.Identifier && element.name === identifierName) {
+    if (element.type === TSESTree12.AST_NODE_TYPES.Identifier && element.name === identifierName) {
       return stableResult.has(index2);
     }
     index2 += 1;
@@ -23026,7 +24181,7 @@ function isStableArrayIndex(stableResult, node, identifierName) {
 }
 function isStableHookValue(init, node, identifierName, stableHooks) {
   const castInit = init;
-  if (castInit.type !== TSESTree11.AST_NODE_TYPES.CallExpression)
+  if (castInit.type !== TSESTree12.AST_NODE_TYPES.CallExpression)
     return false;
   const hookName = getHookName4(castInit);
   if (!hookName)
@@ -23046,35 +24201,35 @@ function isStableValue(variable, identifierName, stableHooks) {
     const { node, type: type3 } = definition;
     if (STABLE_VALUE_TYPES.has(type3))
       return true;
-    if (type3 === "Variable" && node.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator) {
+    if (type3 === "Variable" && node.type === TSESTree12.AST_NODE_TYPES.VariableDeclarator) {
       const { parent } = node;
-      if (!parent || parent.type !== TSESTree11.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const") {
+      if (!parent || parent.type !== TSESTree12.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const") {
         continue;
       }
       const init = node.init;
       if (init && isStableHookValue(init, node, identifierName, stableHooks))
         return true;
-      if (init?.type === TSESTree11.AST_NODE_TYPES.CallExpression) {
+      if (init?.type === TSESTree12.AST_NODE_TYPES.CallExpression) {
         const { callee } = init;
-        if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.property.name === "joinBindings") {
+        if (callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree12.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree12.AST_NODE_TYPES.Identifier && callee.property.name === "joinBindings") {
           return true;
         }
-        if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.property.name === "map") {
+        if (callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree12.AST_NODE_TYPES.Identifier && callee.property.name === "map") {
           return true;
         }
       }
       if (init) {
-        if (init.type === TSESTree11.AST_NODE_TYPES.Literal || init.type === TSESTree11.AST_NODE_TYPES.TemplateLiteral) {
+        if (init.type === TSESTree12.AST_NODE_TYPES.Literal || init.type === TSESTree12.AST_NODE_TYPES.TemplateLiteral) {
           return true;
         }
-        if (init.type === TSESTree11.AST_NODE_TYPES.UnaryExpression && init.argument.type === TSESTree11.AST_NODE_TYPES.Literal) {
+        if (init.type === TSESTree12.AST_NODE_TYPES.UnaryExpression && init.argument.type === TSESTree12.AST_NODE_TYPES.Literal) {
           return true;
         }
       }
       const variableDefinition = variable.defs.find((definition2) => definition2.node === node);
-      if (variableDefinition && variableDefinition.node.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator) {
+      if (variableDefinition && variableDefinition.node.type === TSESTree12.AST_NODE_TYPES.VariableDeclarator) {
         const declarationParent = variableDefinition.node.parent?.parent;
-        if (declarationParent && (declarationParent.type === TSESTree11.AST_NODE_TYPES.Program || declarationParent.type === TSESTree11.AST_NODE_TYPES.ExportNamedDeclaration)) {
+        if (declarationParent && (declarationParent.type === TSESTree12.AST_NODE_TYPES.Program || declarationParent.type === TSESTree12.AST_NODE_TYPES.ExportNamedDeclaration)) {
           testingMetrics.moduleLevelStableConst += 1;
           return true;
         }
@@ -23087,14 +24242,14 @@ function findTopmostMemberExpression(node) {
   let current = node;
   let { parent } = node;
   while (parent) {
-    if (parent.type === TSESTree11.AST_NODE_TYPES.CallExpression && parent.callee === current) {
-      if (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression)
+    if (parent.type === TSESTree12.AST_NODE_TYPES.CallExpression && parent.callee === current) {
+      if (current.type === TSESTree12.AST_NODE_TYPES.MemberExpression)
         return current.object;
       break;
     }
-    const isMemberParent = parent.type === TSESTree11.AST_NODE_TYPES.MemberExpression && parent.object === current;
-    const isChainParent = parent.type === TSESTree11.AST_NODE_TYPES.ChainExpression;
-    const isNonNullParent = parent.type === TSESTree11.AST_NODE_TYPES.TSNonNullExpression;
+    const isMemberParent = parent.type === TSESTree12.AST_NODE_TYPES.MemberExpression && parent.object === current;
+    const isChainParent = parent.type === TSESTree12.AST_NODE_TYPES.ChainExpression;
+    const isNonNullParent = parent.type === TSESTree12.AST_NODE_TYPES.TSNonNullExpression;
     if (!(isMemberParent || isChainParent || isNonNullParent))
       break;
     current = parent;
@@ -23103,21 +24258,21 @@ function findTopmostMemberExpression(node) {
   return current;
 }
 var IS_CEASE_BOUNDARY = new Set([
-  TSESTree11.AST_NODE_TYPES.FunctionDeclaration,
-  TSESTree11.AST_NODE_TYPES.FunctionExpression,
-  TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression,
-  TSESTree11.AST_NODE_TYPES.VariableDeclarator
+  TSESTree12.AST_NODE_TYPES.FunctionDeclaration,
+  TSESTree12.AST_NODE_TYPES.FunctionExpression,
+  TSESTree12.AST_NODE_TYPES.ArrowFunctionExpression,
+  TSESTree12.AST_NODE_TYPES.VariableDeclarator
 ]);
 var TS_RUNTIME_EXPRESSIONS = new Set([
-  TSESTree11.AST_NODE_TYPES.TSNonNullExpression,
-  TSESTree11.AST_NODE_TYPES.TSAsExpression,
-  TSESTree11.AST_NODE_TYPES.TSSatisfiesExpression,
-  TSESTree11.AST_NODE_TYPES.TSTypeAssertion,
-  TSESTree11.AST_NODE_TYPES.TSInstantiationExpression
+  TSESTree12.AST_NODE_TYPES.TSNonNullExpression,
+  TSESTree12.AST_NODE_TYPES.TSAsExpression,
+  TSESTree12.AST_NODE_TYPES.TSSatisfiesExpression,
+  TSESTree12.AST_NODE_TYPES.TSTypeAssertion,
+  TSESTree12.AST_NODE_TYPES.TSInstantiationExpression
 ]);
 function isComputedPropertyIdentifier(identifier3) {
   const { parent } = identifier3;
-  return parent?.type === TSESTree11.AST_NODE_TYPES.Property && parent.computed && parent.key === identifier3;
+  return parent?.type === TSESTree12.AST_NODE_TYPES.Property && parent.computed && parent.key === identifier3;
 }
 function isInTypePosition(identifier3) {
   let parent = identifier3.parent;
@@ -23171,10 +24326,10 @@ function resolveFunctionReference(identifier3, scope) {
     return;
   for (const definition of variable.defs) {
     const { node } = definition;
-    if (node.type === TSESTree11.AST_NODE_TYPES.FunctionDeclaration) {
+    if (node.type === TSESTree12.AST_NODE_TYPES.FunctionDeclaration) {
       return node;
     }
-    if (node.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator && node.init && (node.init.type === TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === TSESTree11.AST_NODE_TYPES.FunctionExpression)) {
+    if (node.type === TSESTree12.AST_NODE_TYPES.VariableDeclarator && node.init && (node.init.type === TSESTree12.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === TSESTree12.AST_NODE_TYPES.FunctionExpression)) {
       return node.init;
     }
   }
@@ -23184,7 +24339,7 @@ function collectCaptures(node, sourceCode) {
   const captures = new Array;
   const captureSet = new Set;
   function visit(current) {
-    if (current.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+    if (current.type === TSESTree12.AST_NODE_TYPES.Identifier) {
       const { name } = current;
       if (captureSet.has(name) || GLOBAL_BUILTINS.has(name) || isInTypePosition(current))
         return;
@@ -23226,21 +24381,21 @@ function collectCaptures(node, sourceCode) {
         }
       }
     }
-    if (current.type === TSESTree11.AST_NODE_TYPES.TSSatisfiesExpression || current.type === TSESTree11.AST_NODE_TYPES.TSAsExpression || current.type === TSESTree11.AST_NODE_TYPES.TSTypeAssertion || current.type === TSESTree11.AST_NODE_TYPES.TSNonNullExpression) {
+    if (current.type === TSESTree12.AST_NODE_TYPES.TSSatisfiesExpression || current.type === TSESTree12.AST_NODE_TYPES.TSAsExpression || current.type === TSESTree12.AST_NODE_TYPES.TSTypeAssertion || current.type === TSESTree12.AST_NODE_TYPES.TSNonNullExpression) {
       visit(current.expression);
       return;
     }
-    if (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === TSESTree12.AST_NODE_TYPES.MemberExpression) {
       visit(current.object);
       if (current.computed)
         visit(current.property);
       return;
     }
-    if (current.type === TSESTree11.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === TSESTree12.AST_NODE_TYPES.ChainExpression) {
       visit(current.expression);
       return;
     }
-    if (current.type === TSESTree11.AST_NODE_TYPES.Property) {
+    if (current.type === TSESTree12.AST_NODE_TYPES.Property) {
       if (current.computed)
         visit(current.key);
       visit(current.value);
@@ -23265,7 +24420,7 @@ function parseDependencies(node, sourceCode) {
   for (const element of node.elements) {
     if (!element)
       continue;
-    const actualNode = element.type === TSESTree11.AST_NODE_TYPES.SpreadElement ? element.argument : element;
+    const actualNode = element.type === TSESTree12.AST_NODE_TYPES.SpreadElement ? element.argument : element;
     const name = nodeToDependencyString(actualNode, sourceCode);
     const depth = getMemberExpressionDepth(actualNode);
     dependencies4.push({
@@ -23342,9 +24497,9 @@ var useExhaustiveDependencies = {
         if (closureArgument === undefined)
           return;
         let closureFunction;
-        if (closureArgument.type === TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression || closureArgument.type === TSESTree11.AST_NODE_TYPES.FunctionExpression) {
+        if (closureArgument.type === TSESTree12.AST_NODE_TYPES.ArrowFunctionExpression || closureArgument.type === TSESTree12.AST_NODE_TYPES.FunctionExpression) {
           closureFunction = closureArgument;
-        } else if (closureArgument.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+        } else if (closureArgument.type === TSESTree12.AST_NODE_TYPES.Identifier) {
           const scope = getScope(callNode);
           closureFunction = resolveFunctionReference(closureArgument, scope);
         }
@@ -23378,7 +24533,7 @@ var useExhaustiveDependencies = {
         }
         if (!dependenciesArgument)
           return;
-        if (dependenciesArgument.type !== TSESTree11.AST_NODE_TYPES.ArrayExpression)
+        if (dependenciesArgument.type !== TSESTree12.AST_NODE_TYPES.ArrayExpression)
           return;
         const dependenciesArray = dependenciesArgument;
         const captures = collectCaptures(closureFunction, context.sourceCode);
@@ -23588,7 +24743,7 @@ var useExhaustiveDependencies = {
 var use_exhaustive_dependencies_default = useExhaustiveDependencies;
 
 // src/rules/use-hook-at-top-level.ts
-import { TSESTree as TSESTree12 } from "@typescript-eslint/types";
+import { TSESTree as TSESTree13 } from "@typescript-eslint/types";
 var HOOK_NAME_PATTERN = /^use[A-Z]/;
 var COMPONENT_NAME_PATTERN2 = /^[A-Z]/;
 function isReactHook(name) {
@@ -23598,23 +24753,23 @@ function isComponent(name) {
   return COMPONENT_NAME_PATTERN2.test(name);
 }
 function isComponentOrHook(node) {
-  if (node.type === TSESTree12.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === TSESTree13.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     const { name } = node.id;
     return isComponent(name) || isReactHook(name);
   }
-  if (node.type === TSESTree12.AST_NODE_TYPES.FunctionExpression || node.type === TSESTree12.AST_NODE_TYPES.ArrowFunctionExpression) {
+  if (node.type === TSESTree13.AST_NODE_TYPES.FunctionExpression || node.type === TSESTree13.AST_NODE_TYPES.ArrowFunctionExpression) {
     const { parent } = node;
     if (parent === undefined)
       return false;
-    if (parent.type === TSESTree12.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree12.AST_NODE_TYPES.Identifier) {
+    if (parent.type === TSESTree13.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree13.AST_NODE_TYPES.Identifier) {
       const { name } = parent.id;
       return isComponent(name) || isReactHook(name);
     }
-    if (parent.type === TSESTree12.AST_NODE_TYPES.Property && parent.key.type === TSESTree12.AST_NODE_TYPES.Identifier) {
+    if (parent.type === TSESTree13.AST_NODE_TYPES.Property && parent.key.type === TSESTree13.AST_NODE_TYPES.Identifier) {
       const { name } = parent.key;
       return isComponent(name) || isReactHook(name);
     }
-    if (parent.type === TSESTree12.AST_NODE_TYPES.MethodDefinition && parent.key.type === TSESTree12.AST_NODE_TYPES.Identifier) {
+    if (parent.type === TSESTree13.AST_NODE_TYPES.MethodDefinition && parent.key.type === TSESTree13.AST_NODE_TYPES.Identifier) {
       const { name } = parent.key;
       return isComponent(name) || isReactHook(name);
     }
@@ -23623,17 +24778,17 @@ function isComponentOrHook(node) {
 }
 function isHookCall(node) {
   const { callee } = node;
-  if (callee.type === TSESTree12.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree13.AST_NODE_TYPES.Identifier)
     return isReactHook(callee.name);
-  if (callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree12.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree13.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree13.AST_NODE_TYPES.Identifier) {
     return isReactHook(callee.property.name);
   }
   return false;
 }
 var FUNCTION_BOUNDARIES2 = new Set([
-  TSESTree12.AST_NODE_TYPES.FunctionDeclaration,
-  TSESTree12.AST_NODE_TYPES.FunctionExpression,
-  TSESTree12.AST_NODE_TYPES.ArrowFunctionExpression
+  TSESTree13.AST_NODE_TYPES.FunctionDeclaration,
+  TSESTree13.AST_NODE_TYPES.FunctionExpression,
+  TSESTree13.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isInFinallyBlock(node) {
   let current = node.parent;
@@ -23642,7 +24797,7 @@ function isInFinallyBlock(node) {
   for (let depth = 0;depth < maxDepth && current; depth += 1) {
     if (FUNCTION_BOUNDARIES2.has(current.type))
       break;
-    if (current.type === TSESTree12.AST_NODE_TYPES.TryStatement) {
+    if (current.type === TSESTree13.AST_NODE_TYPES.TryStatement) {
       let checkNode = node;
       while (checkNode && checkNode !== current) {
         if (checkNode === current.finalizer) {
@@ -23690,14 +24845,14 @@ var useHookAtTopLevel = {
       if (ignoreHooks?.includes(hookName))
         return true;
       if (importSources && Object.keys(importSources).length > 0) {
-        if (node.callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression) {
-          const objectName = node.callee.object.type === TSESTree12.AST_NODE_TYPES.Identifier ? node.callee.object.name : undefined;
+        if (node.callee.type === TSESTree13.AST_NODE_TYPES.MemberExpression) {
+          const objectName = node.callee.object.type === TSESTree13.AST_NODE_TYPES.Identifier ? node.callee.object.name : undefined;
           if (objectName && importSources[objectName] === false)
             return true;
           if (objectName && importSources[objectName] === true)
             return false;
         }
-        if (node.callee.type === TSESTree12.AST_NODE_TYPES.Identifier) {
+        if (node.callee.type === TSESTree13.AST_NODE_TYPES.Identifier) {
           const importSource = importSourceMap.get(hookName);
           if (importSource && importSources[importSource] === false)
             return true;
@@ -23712,7 +24867,7 @@ var useHookAtTopLevel = {
       const current = getCurrentContext();
       const depth = current ? current.functionDepth + 1 : 0;
       const isComponentOrHookFlag = isComponentOrHook(functionNode);
-      if (functionNode.type === TSESTree12.AST_NODE_TYPES.FunctionDeclaration && functionNode.id) {
+      if (functionNode.type === TSESTree13.AST_NODE_TYPES.FunctionDeclaration && functionNode.id) {
         currentFunctionName = functionNode.id.name;
       }
       if (current?.isComponentOrHook) {
@@ -23751,7 +24906,7 @@ var useHookAtTopLevel = {
         if (!isHookCall(callNode))
           return;
         const { callee } = callNode;
-        const hookName = callee.type === TSESTree12.AST_NODE_TYPES.Identifier ? callee.name : callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree12.AST_NODE_TYPES.Identifier ? callee.property.name : undefined;
+        const hookName = callee.type === TSESTree13.AST_NODE_TYPES.Identifier ? callee.name : callee.type === TSESTree13.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree13.AST_NODE_TYPES.Identifier ? callee.property.name : undefined;
         if (!hookName || shouldIgnoreHook(hookName, callNode))
           return;
         const current = getCurrentContext();
@@ -23849,10 +25004,10 @@ var useHookAtTopLevel = {
         if (!configuration.importSources || Object.keys(configuration.importSources).length === 0)
           return;
         for (const specifier of importNode.specifiers) {
-          if (specifier.type !== TSESTree12.AST_NODE_TYPES.ImportSpecifier)
+          if (specifier.type !== TSESTree13.AST_NODE_TYPES.ImportSpecifier)
             continue;
           const { imported } = specifier;
-          if (imported.type !== TSESTree12.AST_NODE_TYPES.Identifier)
+          if (imported.type !== TSESTree13.AST_NODE_TYPES.Identifier)
             continue;
           if (isReactHook(imported.name))
             importSourceMap.set(specifier.local.name, source);
@@ -23961,6 +25116,9 @@ function createNoInstanceMethodsOptions(options3 = {}) {
     ...options3
   };
 }
+function createNoMemoChildrenOptions(options3 = {}) {
+  return { allowedComponents: [], environment: "roblox-ts", ...options3 };
+}
 function createNoShorthandOptions(options3 = {}) {
   return { allowPropertyAccess: [], ignoreShorthands: [], shorthands: {}, ...options3 };
 }
@@ -24044,6 +25202,7 @@ var rules = {
   "no-god-components": no_god_components_default,
   "no-identity-map": no_identity_map_default,
   "no-instance-methods-without-this": no_instance_methods_without_this_default,
+  "no-memo-children": no_memo_children_default,
   "no-print": no_print_default,
   "no-shorthand-names": no_shorthand_names_default,
   "no-useless-use-spring": no_useless_use_spring_default,
@@ -24079,6 +25238,7 @@ var recommended = {
     "cease-nonsense/no-god-components": "error",
     "cease-nonsense/no-identity-map": "error",
     "cease-nonsense/no-instance-methods-without-this": "error",
+    "cease-nonsense/no-memo-children": "error",
     "cease-nonsense/no-print": "error",
     "cease-nonsense/no-shorthand-names": "error",
     "cease-nonsense/no-warn": "error",
@@ -24109,6 +25269,7 @@ export {
   createPairConfiguration,
   createNoUselessUseSpringOptions,
   createNoShorthandOptions,
+  createNoMemoChildrenOptions,
   createNoInstanceMethodsOptions,
   createNoGodComponentsOptions,
   createHookConfiguration,
@@ -24116,5 +25277,3 @@ export {
   createComplexityConfiguration,
   createBanInstancesOptions
 };
-
-//# debugId=82B8719F042D688964756E2164756E21