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

package/dist/index.js

@@ -19752,8 +19752,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 ESLintUtils3 } 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 +20584,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 +20593,153 @@ function createEnumMatch(enumPath) {
 }
 var prefer_enum_item_default = createRule({
   create(context) {
-    const [{ fixNumericToValue = false } = {}] = context.options;
+    const [{ fixNumericToValue = false, performanceMode = false } = {}] = context.options;
     const services = ESLintUtils3.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 +20762,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 +20775,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 +20784,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 +20792,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 +20809,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 +20826,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 +20834,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 +20851,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 +20886,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 +20926,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 +20971,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 +20989,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 +21005,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 +21049,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 +21073,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 +21101,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 +21391,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 +21411,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 +21446,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;
@@ -20855,16 +21814,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 +21847,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 +21880,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 +21909,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;
         }
       },
@@ -21348,7 +22307,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 +22325,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 +22374,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 +22641,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 +22656,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 +22705,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 +22724,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 +22787,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 +22818,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 +22835,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 +22843,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 +22981,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",
@@ -24117,4 +25076,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=82B8719F042D688964756E2164756E21
+//# debugId=A96F64DDBF4FBDA864756E2164756E21