@sarj/eslint-plugin 16.32.0 → 16.32.3

package/dist/index.js

@@ -1,9 +1,61 @@
 // src/rules/no-redundant-consumer-union.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES6, ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
-import ts5 from "typescript";
+import ts7 from "typescript";
 
-// src/rules/_closed-object-contract.ts
+// src/rules/_checked-native-source.ts
 import ts from "typescript";
+var CHECKED = /* @__PURE__ */ new WeakMap();
+var SINGLE_LINE_DIRECTIVE = /^\/\/\/?\s*@(?:ts-expect-error|ts-ignore)/u;
+var MULTI_LINE_DIRECTIVE = /^[/*]*\s*@(?:ts-expect-error|ts-ignore)/u;
+var SINGLE_LINE_PRAGMA = /^\/\/\/?\s*@([^\s:]+)(?:(?:[^\S\r\n]|:).*)?$/mu;
+function currentNativeSource(sourceCode, services) {
+  const source = services.esTreeNodeToTSNodeMap.get(sourceCode.ast);
+  return ts.isSourceFile(source) && services.program.getSourceFile(source.fileName) === source && source.text === sourceCode.text ? source : null;
+}
+function checkedNativeSource(program, source) {
+  let files = CHECKED.get(program);
+  if (!files) {
+    files = /* @__PURE__ */ new WeakMap();
+    CHECKED.set(program, files);
+  }
+  const known2 = files.get(source);
+  if (known2 !== void 0) return known2;
+  const available = !program.getCompilerOptions().noCheck && !source.isDeclarationFile && (source.flags & (ts.NodeFlags.JavaScriptFile | ts.NodeFlags.JsonFile)) === 0 && !program.getProjectReferences()?.length && !program.getResolvedProjectReferences()?.length && program.getSourceFile(source.fileName) === source && !program.isSourceFileFromExternalLibrary(source) && !program.isSourceFileDefaultLibrary(source) && !program.getSyntacticDiagnostics(source).some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error && diagnostic.file === source) && !checkingSuppressed(source) && !program.getSemanticDiagnostics(source).some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error && diagnostic.file === source);
+  files.set(source, available);
+  return available;
+}
+function checkingSuppressed(source) {
+  if (!/@ts-/iu.test(source.text)) return false;
+  if (ts.getLeadingCommentRanges(source.text, 0)?.some((comment) => comment.kind === ts.SyntaxKind.SingleLineCommentTrivia && SINGLE_LINE_PRAGMA.exec(source.text.slice(comment.pos, comment.end))?.[1]?.toLowerCase() === "ts-nocheck")) return true;
+  const pending = [source];
+  while (pending.length) {
+    const node = pending.pop();
+    if (!node || ts.isJsxText(node) || ts.isJSDoc(node) || (node.flags & ts.NodeFlags.JSDoc) !== 0) continue;
+    if (!ts.isToken(node)) {
+      for (const child of node.getChildren(source)) pending.push(child);
+      continue;
+    }
+    if (tokenTriviaSuppressesChecking(node, source)) return true;
+  }
+  return false;
+}
+function tokenTriviaSuppressesChecking(node, source) {
+  const start = node.getStart(source);
+  for (const comment of [...ts.getLeadingCommentRanges(source.text, node.pos) ?? [], ...ts.getTrailingCommentRanges(source.text, node.pos) ?? []]) {
+    if (comment.pos < node.pos || comment.end > start) continue;
+    if (commentSuppressesChecking(source.text.slice(comment.pos, comment.end), comment.kind)) return true;
+  }
+  return false;
+}
+function commentSuppressesChecking(text, kind) {
+  if (kind === ts.SyntaxKind.SingleLineCommentTrivia) return SINGLE_LINE_DIRECTIVE.test(text);
+  let lastLine = text.length;
+  while (lastLine > 0 && !ts.isLineBreak(text.charCodeAt(lastLine - 1))) lastLine--;
+  return MULTI_LINE_DIRECTIVE.test(text.slice(lastLine).trimStart());
+}
+
+// src/rules/_closed-object-contract.ts
+import ts2 from "typescript";
 function closedObjectContract(type, checker) {
   return visitContract(type, { checker, active: /* @__PURE__ */ new Set(), completed: /* @__PURE__ */ new WeakMap() });
 }
@@ -19,32 +71,32 @@ function visitContract(type, proof) {
 }
 function completeObject(type, proof) {
   if (!ordinaryObject(type, proof.checker)) return false;
-  const declarations = type.getSymbol()?.getDeclarations()?.filter((declaration) => ts.isInterfaceDeclaration(declaration) || ts.isTypeLiteralNode(declaration));
+  const declarations = type.getSymbol()?.getDeclarations()?.filter((declaration) => ts2.isInterfaceDeclaration(declaration) || ts2.isTypeLiteralNode(declaration));
   if (!declarations?.length) return false;
   return declarations.every((declaration) => completeDeclaration(declaration, proof));
 }
 function ordinaryObject(type, checker) {
-  if ((type.flags & ts.TypeFlags.Object) === 0 || type.isUnion() || checker.getIndexInfosOfType(type).length > 0) return false;
+  if ((type.flags & ts2.TypeFlags.Object) === 0 || type.isUnion() || checker.getIndexInfosOfType(type).length > 0) return false;
   const object = type;
-  if ((object.objectFlags & (ts.ObjectFlags.Class | ts.ObjectFlags.Mapped)) !== 0) return false;
-  if ((object.objectFlags & ts.ObjectFlags.Reference) !== 0 && checker.getTypeArguments(type).some((argument) => (argument.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter)) !== 0)) return false;
-  return checker.getSignaturesOfType(type, ts.SignatureKind.Call).length === 0 && checker.getSignaturesOfType(type, ts.SignatureKind.Construct).length === 0;
+  if ((object.objectFlags & (ts2.ObjectFlags.Class | ts2.ObjectFlags.Mapped)) !== 0) return false;
+  if ((object.objectFlags & ts2.ObjectFlags.Reference) !== 0 && checker.getTypeArguments(type).some((argument) => (argument.flags & (ts2.TypeFlags.Any | ts2.TypeFlags.Unknown | ts2.TypeFlags.TypeParameter)) !== 0)) return false;
+  return checker.getSignaturesOfType(type, ts2.SignatureKind.Call).length === 0 && checker.getSignaturesOfType(type, ts2.SignatureKind.Construct).length === 0;
 }
 function completeDeclaration(declaration, proof) {
   if (!declaration.members.every((member3) => finiteMember(member3, proof.checker))) return false;
-  if (!ts.isInterfaceDeclaration(declaration)) return true;
+  if (!ts2.isInterfaceDeclaration(declaration)) return true;
   if (declaration.typeParameters?.length) return false;
   return (declaration.heritageClauses ?? []).every((heritage) => heritage.types.every((base) => visitContract(proof.checker.getTypeAtLocation(base), proof)));
 }
 function finiteMember(member3, checker) {
-  if (ts.isIndexSignatureDeclaration(member3)) return false;
-  if (!member3.name || !ts.isComputedPropertyName(member3.name)) return true;
-  return (checker.getTypeAtLocation(member3.name.expression).flags & (ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral | ts.TypeFlags.UniqueESSymbol)) !== 0;
+  if (ts2.isIndexSignatureDeclaration(member3)) return false;
+  if (!member3.name || !ts2.isComputedPropertyName(member3.name)) return true;
+  return (checker.getTypeAtLocation(member3.name.expression).flags & (ts2.TypeFlags.StringLiteral | ts2.TypeFlags.NumberLiteral | ts2.TypeFlags.UniqueESSymbol)) !== 0;
 }
 
 // src/rules/_private-consumer-fix.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
-import ts2 from "typescript";
+import ts3 from "typescript";
 
 // src/rules/_type-binding.ts
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
@@ -89,7 +141,7 @@ function insideTypeRange(node, range) {
 }
 
 // src/rules/_private-consumer-fix.ts
-var UNSAFE = ts2.TypeFlags.Any | ts2.TypeFlags.Unknown | ts2.TypeFlags.Never | ts2.TypeFlags.TypeParameter | ts2.TypeFlags.Conditional | ts2.TypeFlags.IndexedAccess | ts2.TypeFlags.Substitution;
+var UNSAFE = ts3.TypeFlags.Any | ts3.TypeFlags.Unknown | ts3.TypeFlags.Never | ts3.TypeFlags.TypeParameter | ts3.TypeFlags.Conditional | ts3.TypeFlags.IndexedAccess | ts3.TypeFlags.Substitution;
 function validConsumerFixCalls(node, parameter, sourceCode, services) {
   if (sourceCode.getAllComments().some((comment) => /@ts-(?:expect-error|ignore|nocheck)\b/u.test(comment.value))) return false;
   const owner = node.type === AST_NODE_TYPES2.FunctionDeclaration ? node : node.parent;
@@ -486,58 +538,75 @@ function commentLineEnd(sourceText, start) {
 
 // src/rules/_private-scalar-consumer.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
+import ts6 from "typescript";
+
+// src/rules/_scalar-parameter-view.ts
+import ts5 from "typescript";
+
+// src/rules/_native-const-value.ts
 import ts4 from "typescript";
+function constInitializer(declaration) {
+  if (!declaration || !ts4.isVariableDeclaration(declaration) || !ts4.isVariableDeclarationList(declaration.parent) || (declaration.parent.flags & ts4.NodeFlags.BlockScoped) !== ts4.NodeFlags.Const) return void 0;
+  let initializer = declaration.initializer;
+  while (initializer && ts4.isParenthesizedExpression(initializer)) initializer = initializer.expression;
+  return initializer;
+}
+function unassertedValue(node) {
+  let value = node;
+  while (ts4.isParenthesizedExpression(value) || ts4.isAsExpression(value) || ts4.isTypeAssertionExpression(value) || ts4.isNonNullExpression(value) || ts4.isSatisfiesExpression(value)) value = value.expression;
+  return value;
+}
 
 // src/rules/_scalar-parameter-view.ts
-import ts3 from "typescript";
 var SCALAR_OPERATORS = /* @__PURE__ */ new Set([
-  ts3.SyntaxKind.PlusToken,
-  ts3.SyntaxKind.MinusToken,
-  ts3.SyntaxKind.AsteriskToken,
-  ts3.SyntaxKind.SlashToken,
-  ts3.SyntaxKind.PercentToken,
-  ts3.SyntaxKind.AsteriskAsteriskToken,
-  ts3.SyntaxKind.LessThanToken,
-  ts3.SyntaxKind.LessThanEqualsToken,
-  ts3.SyntaxKind.GreaterThanToken,
-  ts3.SyntaxKind.GreaterThanEqualsToken,
-  ts3.SyntaxKind.EqualsEqualsEqualsToken,
-  ts3.SyntaxKind.ExclamationEqualsEqualsToken,
-  ts3.SyntaxKind.EqualsEqualsToken,
-  ts3.SyntaxKind.ExclamationEqualsToken,
-  ts3.SyntaxKind.AmpersandAmpersandToken,
-  ts3.SyntaxKind.BarBarToken,
-  ts3.SyntaxKind.QuestionQuestionToken
+  ts5.SyntaxKind.PlusToken,
+  ts5.SyntaxKind.MinusToken,
+  ts5.SyntaxKind.AsteriskToken,
+  ts5.SyntaxKind.SlashToken,
+  ts5.SyntaxKind.PercentToken,
+  ts5.SyntaxKind.AsteriskAsteriskToken,
+  ts5.SyntaxKind.LessThanToken,
+  ts5.SyntaxKind.LessThanEqualsToken,
+  ts5.SyntaxKind.GreaterThanToken,
+  ts5.SyntaxKind.GreaterThanEqualsToken,
+  ts5.SyntaxKind.EqualsEqualsEqualsToken,
+  ts5.SyntaxKind.ExclamationEqualsEqualsToken,
+  ts5.SyntaxKind.EqualsEqualsToken,
+  ts5.SyntaxKind.ExclamationEqualsToken,
+  ts5.SyntaxKind.AmpersandAmpersandToken,
+  ts5.SyntaxKind.BarBarToken,
+  ts5.SyntaxKind.QuestionQuestionToken
 ]);
-var SCALAR_PREFIXES = /* @__PURE__ */ new Set([ts3.SyntaxKind.PlusToken, ts3.SyntaxKind.MinusToken, ts3.SyntaxKind.ExclamationToken, ts3.SyntaxKind.TildeToken]);
+var SCALAR_PREFIXES = /* @__PURE__ */ new Set([ts5.SyntaxKind.PlusToken, ts5.SyntaxKind.MinusToken, ts5.SyntaxKind.ExclamationToken, ts5.SyntaxKind.TildeToken]);
+var RETURNED_OPERANDS = /* @__PURE__ */ new Set([ts5.SyntaxKind.AmpersandAmpersandToken, ts5.SyntaxKind.BarBarToken, ts5.SyntaxKind.QuestionQuestionToken]);
 function scalarParameterView(parameter, body3, checker) {
   return parameterReads(parameter, body3, checker, true);
 }
-function scalarParameterReads(parameter, body3, checker) {
-  return parameterReads(parameter, body3, checker, false);
+function scalarParameterReads(parameter, body3, checker, callProgram) {
+  return parameterReads(parameter, body3, checker, false, callProgram);
 }
-function parameterReads(parameter, body3, checker, jsx) {
-  if (parameter.dotDotDotToken || parameter.initializer || ts3.isArrayBindingPattern(parameter.name)) return null;
-  const root = ts3.isIdentifier(parameter.name) ? checker.getSymbolAtLocation(parameter.name) : void 0;
-  if (ts3.isIdentifier(parameter.name) && !root) return null;
+function parameterReads(parameter, body3, checker, jsx, callProgram) {
+  if (parameter.dotDotDotToken || parameter.initializer || ts5.isArrayBindingPattern(parameter.name)) return null;
+  const root = ts5.isIdentifier(parameter.name) ? checker.getSymbolAtLocation(parameter.name) : void 0;
+  if (ts5.isIdentifier(parameter.name) && !root) return null;
   const reads = /* @__PURE__ */ new Set();
   const aliases = parameterAliases(parameter.name, checker, reads);
   if (!aliases) return null;
   const expression = returnedExpression(body3);
-  const view = { checker, props: checker.getTypeAtLocation(parameter), root, aliases, reads, jsx };
-  return expression && scalarView(expression, view) ? reads : null;
+  const view = { checker, props: checker.getTypeAtLocation(parameter), root, aliases, reads, callProgram };
+  return expression && scalarView(expression, view, jsx) ? reads : null;
 }
 function scalarType(type, allowUndefined = true) {
   if (type.isUnion()) return type.types.every((part) => scalarType(part, allowUndefined));
-  const flags = ts3.TypeFlags.StringLike | ts3.TypeFlags.NumberLike | ts3.TypeFlags.BooleanLike | ts3.TypeFlags.BigIntLike | ts3.TypeFlags.Null;
-  return (type.flags & (allowUndefined ? flags | ts3.TypeFlags.Undefined : flags)) !== 0;
+  const flags = ts5.TypeFlags.StringLike | ts5.TypeFlags.NumberLike | ts5.TypeFlags.BooleanLike | ts5.TypeFlags.BigIntLike | ts5.TypeFlags.Null;
+  return (type.flags & (allowUndefined ? flags | ts5.TypeFlags.Undefined : flags)) !== 0;
 }
 function parameterAliases(name, checker, reads) {
   const aliases = /* @__PURE__ */ new Map();
-  if (ts3.isIdentifier(name)) return aliases;
+  if (ts5.isIdentifier(name)) return aliases;
   for (const element of name.elements) {
     const key = element.propertyName ?? element.name;
-    if (element.dotDotDotToken || element.initializer || !ts3.isIdentifier(element.name) || !ts3.isIdentifier(key) && !ts3.isStringLiteralLike(key) && !ts3.isNumericLiteral(key)) return null;
+    if (element.dotDotDotToken || element.initializer || !ts5.isIdentifier(element.name) || !ts5.isIdentifier(key) && !ts5.isStringLiteralLike(key) && !ts5.isNumericLiteral(key)) return null;
     const binding3 = checker.getSymbolAtLocation(element.name);
     if (!binding3) return null;
     reads.add(key.text);
@@ -546,31 +615,56 @@ function parameterAliases(name, checker, reads) {
   return aliases;
 }
 function returnedExpression(body3) {
-  if (!ts3.isBlock(body3)) return body3;
+  if (!ts5.isBlock(body3)) return body3;
   const statement = body3.statements.length === 1 ? body3.statements[0] : void 0;
-  return statement && ts3.isReturnStatement(statement) ? statement.expression : void 0;
+  return statement && ts5.isReturnStatement(statement) ? statement.expression : void 0;
 }
-function scalarView(node, view) {
+function scalarView(node, view, jsx = false) {
   if (scalarLiteral(node)) return true;
-  if (ts3.isIdentifier(node)) {
+  if (ts5.isCallExpression(node)) return !jsx && scalarCall(node, view);
+  if (ts5.isJsxExpression(node)) return !node.dotDotDotToken && (!node.expression || scalarView(node.expression, view, jsx));
+  if (ts5.isIdentifier(node)) {
     const binding3 = view.checker.getSymbolAtLocation(node);
     const key = binding3 && view.aliases.get(binding3);
     return key !== void 0 && readField(node, key, view);
   }
-  if (ts3.isPropertyAccessExpression(node) || ts3.isElementAccessExpression(node)) return memberRead(node, view);
-  if (ts3.isParenthesizedExpression(node) || ts3.isNonNullExpression(node) || ts3.isTypeOfExpression(node)) return scalarView(node.expression, view);
-  if (ts3.isConditionalExpression(node)) return scalarView(node.condition, view) && scalarView(node.whenTrue, view) && scalarView(node.whenFalse, view);
-  if (ts3.isBinaryExpression(node)) return SCALAR_OPERATORS.has(node.operatorToken.kind) && scalarView(node.left, view) && scalarView(node.right, view);
-  if (ts3.isPrefixUnaryExpression(node)) return SCALAR_PREFIXES.has(node.operator) && scalarView(node.operand, view);
-  if (ts3.isTemplateExpression(node)) return node.templateSpans.every((span) => scalarView(span.expression, view));
-  return view.jsx && jsxView(node, view);
+  if (ts5.isPropertyAccessExpression(node) || ts5.isElementAccessExpression(node)) return memberRead(node, view);
+  return scalarOperation(node, view, jsx);
+}
+function scalarOperation(node, view, jsx) {
+  if (ts5.isParenthesizedExpression(node) || ts5.isNonNullExpression(node)) return scalarView(node.expression, view, jsx);
+  if (ts5.isTypeOfExpression(node)) return scalarView(node.expression, view);
+  if (ts5.isConditionalExpression(node)) return scalarView(node.condition, view) && scalarView(node.whenTrue, view, jsx) && scalarView(node.whenFalse, view, jsx);
+  if (ts5.isBinaryExpression(node)) return binaryView(node, view, jsx);
+  if (ts5.isPrefixUnaryExpression(node)) return SCALAR_PREFIXES.has(node.operator) && scalarView(node.operand, view);
+  if (ts5.isTemplateExpression(node)) return node.templateSpans.every((span) => scalarView(span.expression, view));
+  return jsx && jsxView(node, view);
+}
+function scalarCall(node, view) {
+  if (!view.callProgram || node.questionDotToken || node.typeArguments?.length || !ts5.isIdentifier(node.expression) || !node.arguments.length || node.arguments.some(ts5.isSpreadElement)) return false;
+  const declarations = view.checker.getSymbolAtLocation(node.expression)?.declarations;
+  const declaration = declarations?.length === 1 ? declarations[0] : void 0;
+  const helper = declaration && localHelper(declaration);
+  if (!helper || helper.getSourceFile() !== node.getSourceFile() || helper.typeParameters?.length || !helper.type || !node.arguments.every((argument) => scalarView(argument, view))) return false;
+  if (!checkedNativeSource(view.callProgram, node.getSourceFile())) return false;
+  const signature = view.checker.getResolvedSignature(node);
+  return signature?.declaration === helper && !view.checker.getTypePredicateOfSignature(signature) && scalarType(view.checker.getTypeAtLocation(node));
+}
+function localHelper(node) {
+  if (ts5.isFunctionDeclaration(node)) return node.body && ts5.isSourceFile(node.parent) ? node : void 0;
+  if (!ts5.isVariableDeclaration(node) || node.type || !node.initializer || constInitializer(node) !== node.initializer || !ts5.isArrowFunction(node.initializer) || !ts5.isVariableStatement(node.parent.parent) || !ts5.isSourceFile(node.parent.parent.parent)) return void 0;
+  return node.initializer;
+}
+function binaryView(node, view, jsx) {
+  const returned2 = jsx && RETURNED_OPERANDS.has(node.operatorToken.kind);
+  return SCALAR_OPERATORS.has(node.operatorToken.kind) && scalarView(node.left, view, returned2) && scalarView(node.right, view, returned2);
 }
 function scalarLiteral(node) {
-  return ts3.isStringLiteralLike(node) || ts3.isNumericLiteral(node) || ts3.isBigIntLiteral(node) || ts3.isJsxText(node) || node.kind === ts3.SyntaxKind.TrueKeyword || node.kind === ts3.SyntaxKind.FalseKeyword || node.kind === ts3.SyntaxKind.NullKeyword;
+  return ts5.isStringLiteralLike(node) || ts5.isNumericLiteral(node) || ts5.isBigIntLiteral(node) || ts5.isJsxText(node) || node.kind === ts5.SyntaxKind.TrueKeyword || node.kind === ts5.SyntaxKind.FalseKeyword || node.kind === ts5.SyntaxKind.NullKeyword;
 }
 function memberRead(node, view) {
-  if (!view.root || !ts3.isIdentifier(node.expression) || view.checker.getSymbolAtLocation(node.expression) !== view.root) return false;
-  const key = ts3.isPropertyAccessExpression(node) ? node.name.text : node.argumentExpression && (ts3.isStringLiteralLike(node.argumentExpression) || ts3.isNumericLiteral(node.argumentExpression)) ? node.argumentExpression.text : void 0;
+  if (!view.root || !ts5.isIdentifier(node.expression) || view.checker.getSymbolAtLocation(node.expression) !== view.root) return false;
+  const key = ts5.isPropertyAccessExpression(node) ? node.name.text : node.argumentExpression && (ts5.isStringLiteralLike(node.argumentExpression) || ts5.isNumericLiteral(node.argumentExpression)) ? node.argumentExpression.text : void 0;
   return key !== void 0 && readField(node, key, view);
 }
 function readField(node, key, view) {
@@ -579,15 +673,14 @@ function readField(node, key, view) {
   return true;
 }
 function jsxView(node, view) {
-  if (ts3.isJsxExpression(node)) return !node.dotDotDotToken && (!node.expression || scalarView(node.expression, view));
-  if (ts3.isJsxFragment(node)) return node.children.every((child) => scalarView(child, view));
-  if (ts3.isJsxElement(node)) return jsxView(node.openingElement, view) && node.children.every((child) => scalarView(child, view));
-  if (!ts3.isJsxOpeningElement(node) && !ts3.isJsxSelfClosingElement(node)) return false;
-  if (!ts3.isIdentifier(node.tagName) || !/^[a-z][A-Za-z0-9]*$/u.test(node.tagName.text)) return false;
+  if (ts5.isJsxFragment(node)) return node.children.every((child) => scalarView(child, view, true));
+  if (ts5.isJsxElement(node)) return jsxView(node.openingElement, view) && node.children.every((child) => scalarView(child, view, true));
+  if (!ts5.isJsxOpeningElement(node) && !ts5.isJsxSelfClosingElement(node)) return false;
+  if (!ts5.isIdentifier(node.tagName) || !/^[a-z][A-Za-z0-9]*$/u.test(node.tagName.text)) return false;
   return node.attributes.properties.every((attribute) => intrinsicAttribute(attribute, view));
 }
 function intrinsicAttribute(attribute, view) {
-  return ts3.isJsxAttribute(attribute) && ts3.isIdentifier(attribute.name) && attribute.name.text !== "is" && (!attribute.initializer || scalarView(attribute.initializer, view));
+  return ts5.isJsxAttribute(attribute) && ts5.isIdentifier(attribute.name) && attribute.name.text !== "is" && (!attribute.initializer || scalarView(attribute.initializer, view));
 }
 
 // src/rules/_stable-value-binding.ts
@@ -640,7 +733,7 @@ function directEval(node) {
   return callee.type === AST_NODE_TYPES5.Identifier && callee.name === "eval";
 }
 function primitiveKeyword(node) {
-  return node !== void 0 && (node.kind === ts4.SyntaxKind.StringKeyword || node.kind === ts4.SyntaxKind.NumberKeyword || node.kind === ts4.SyntaxKind.BooleanKeyword || node.kind === ts4.SyntaxKind.BigIntKeyword);
+  return node !== void 0 && (node.kind === ts6.SyntaxKind.StringKeyword || node.kind === ts6.SyntaxKind.NumberKeyword || node.kind === ts6.SyntaxKind.BooleanKeyword || node.kind === ts6.SyntaxKind.BigIntKeyword);
 }
 function consumerAnnotation(node) {
   if (node.params.length !== 1) return void 0;
@@ -649,31 +742,31 @@ function consumerAnnotation(node) {
 }
 function exportedSymbols(source, checker) {
   const symbol = checker.getSymbolAtLocation(source);
-  return new Set(symbol ? checker.getExportsOfModule(symbol).map((entry) => (entry.flags & ts4.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(entry) : entry) : []);
+  return new Set(symbol ? checker.getExportsOfModule(symbol).map((entry) => (entry.flags & ts6.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(entry) : entry) : []);
 }
-function privateScalarConsumer(node, sourceCode, services, exports) {
+function privateScalarConsumer(node, sourceCode, services, exports, scalarCalls = false) {
   const native = services.esTreeNodeToTSNodeMap.get(node);
-  if (!ts4.isFunctionDeclaration(native) && !ts4.isArrowFunction(native) || !native.body || !independentSignature(native)) return null;
+  if (!ts6.isFunctionDeclaration(native) && !ts6.isArrowFunction(native) || !native.body || !independentSignature(native)) return null;
   const checker = services.program.getTypeChecker();
-  if (!ts4.isExternalModule(native.getSourceFile()) || !services.program.getCompilerOptions().strict) return null;
+  if (!ts6.isExternalModule(native.getSourceFile()) || !services.program.getCompilerOptions().strict) return null;
   const parameter = native.parameters[0];
   if (!parameter) return null;
   const binding3 = callableBinding(node, sourceCode);
   if (!binding3 || binding3.defs.length !== 1) return null;
-  const name = ts4.isFunctionDeclaration(native) ? native.name : ts4.isVariableDeclaration(native.parent) ? native.parent.name : void 0;
+  const name = ts6.isFunctionDeclaration(native) ? native.name : ts6.isVariableDeclaration(native.parent) ? native.parent.name : void 0;
   const symbol = name && checker.getSymbolAtLocation(name);
   if (!symbol || symbol.declarations?.length !== 1 || exports.has(symbol) || !directCalls(binding3)) return null;
   const signature = checker.getSignatureFromDeclaration(native);
   if (!signature || signature.typeParameters?.length || checker.getTypePredicateOfSignature(signature)) return null;
   const expression = returnedExpression(native.body);
   if (!expression || !checker.isTypeAssignableTo(checker.getTypeAtLocation(expression), checker.getReturnTypeOfSignature(signature))) return null;
-  const reads = scalarParameterReads(parameter, native.body, checker);
+  const reads = scalarParameterReads(parameter, native.body, checker, scalarCalls ? services.program : void 0);
   return reads?.size ? { parameter, reads } : null;
 }
 function independentSignature(native) {
   if (native.parameters.length !== 1 || native.typeParameters?.length || native.asteriskToken || native.modifiers?.length || !primitiveKeyword(native.type)) return false;
   const parameter = native.parameters[0];
-  return parameter !== void 0 && parameter.type !== void 0 && !parameter.modifiers?.length && !parameter.questionToken && !parameter.initializer && !parameter.dotDotDotToken && (!ts4.isIdentifier(parameter.name) || parameter.name.text !== "this");
+  return parameter !== void 0 && parameter.type !== void 0 && !parameter.modifiers?.length && !parameter.questionToken && !parameter.initializer && !parameter.dotDotDotToken && (!ts6.isIdentifier(parameter.name) || parameter.name.text !== "this");
 }
 function callableBinding(node, sourceCode) {
   if (node.type === AST_NODE_TYPES5.FunctionDeclaration) {
@@ -723,8 +816,8 @@ function scalarFields(type, checker) {
   const fields = /* @__PURE__ */ new Map();
   for (const property of type.getProperties()) {
     const declarations = property.getDeclarations();
-    if (!declarations?.length || !declarations.every((member3) => ts5.isPropertySignature(member3) && member3.name && (ts5.isIdentifier(member3.name) || ts5.isStringLiteralLike(member3.name)) && member3.modifiers?.length === 1 && member3.modifiers[0]?.kind === ts5.SyntaxKind.ReadonlyKeyword && primitiveKeyword(member3.type))) return null;
-    fields.set(property.name, (property.flags & ts5.SymbolFlags.Optional) === 0);
+    if (!declarations?.length || !declarations.every((member3) => ts7.isPropertySignature(member3) && member3.name && (ts7.isIdentifier(member3.name) || ts7.isStringLiteralLike(member3.name)) && member3.modifiers?.length === 1 && member3.modifiers[0]?.kind === ts7.SyntaxKind.ReadonlyKeyword && primitiveKeyword(member3.type))) return null;
+    fields.set(property.name, (property.flags & ts7.SymbolFlags.Optional) === 0);
   }
   return fields.size ? fields : null;
 }
@@ -758,8 +851,10 @@ var no_redundant_consumer_union_default = createRule({
       "Program:exit"() {
         if (dynamic || !candidates.length) return;
         const services = ESLintUtils2.getParserServices(context);
+        const source = currentNativeSource(context.sourceCode, services);
+        if (!source) return;
         const checker = services.program.getTypeChecker();
-        const exports = exportedSymbols(services.esTreeNodeToTSNodeMap.get(context.sourceCode.ast), checker);
+        const exports = exportedSymbols(source, checker);
         const candidateAnnotations = candidates.flatMap((node) => {
           const annotation = consumerAnnotation(node);
           return annotation ? [annotation] : [];
@@ -772,7 +867,7 @@ var no_redundant_consumer_union_default = createRule({
         for (const candidate2 of candidates) {
           const consumer = privateScalarConsumer(candidate2, context.sourceCode, services, exports);
           const annotation = consumer?.parameter.type;
-          if (!consumer || !annotation || !ts5.isUnionTypeNode(annotation) || annotation.types.length !== 2) continue;
+          if (!consumer || !annotation || !ts7.isUnionTypeNode(annotation) || annotation.types.length !== 2) continue;
           const leftNode = annotation.types[0];
           const rightNode = annotation.types[1];
           if (!leftNode || !rightNode) continue;
@@ -804,9 +899,10 @@ var no_redundant_consumer_union_default = createRule({
 
 // src/rules/prefer-minimal-parameter-contract.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
-import ts6 from "typescript";
+import ts8 from "typescript";
 var CONFIG2 = { path: "tsconfig.json", source: '{"compilerOptions":{"strict":true,"target":"ESNext","module":"ESNext","moduleResolution":"Bundler"}}' };
 var EXAMPLE2 = 'export {}; const account = {name: "Ada", email: "a"}; function label(user: {readonly email: string; readonly name: string}): string {return user.name;} label(account);';
+var HELPER_EXAMPLE = 'export {}; const account = {name: "Ada", email: "a"}; function formatName(name: string): string {return name.toUpperCase();} function label(user: {email: string; name: string}): string {return formatName(user.name);} label(account);';
 var PREFER_MINIMAL_PARAMETER_CONTRACT_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Prefer the proven read-only subset for a private consumer parameter.",
@@ -817,18 +913,20 @@ var PREFER_MINIMAL_PARAMETER_CONTRACT_DOCUMENTATION = {
   limitations: [
     "Automatic fixes additionally require every existing identifier caller to be natively assignable to the original contract, without Any, unknown, error or unresolved types on the relevant surface. Comments inside the annotation and TypeScript suppression directives keep the finding manual. Only unread required property signatures are removed; every read or optional member, modifier and terminator token is preserved. Edits that would merge distinct CR and LF terminators remain manual.",
     "Requires parser-owned TypeScript information and a strict external module. Only top-level private function declarations and raw const arrows with exactly one explicit parameter and an independent broad primitive return annotation are supported. Every callable reference must be a direct call with one identifier argument; exports including type-only exports, typeof queries, callbacks, storage, constructors, contextual signatures, overloads, generics, decorators, async functions and direct eval prevent findings.",
-    "Only anonymous inline contracts made of explicitly readonly string, number, boolean or bigint properties are supported. Named domain contracts, brands, literal discriminants, classes, methods, callbacks, indexes, mapped types and imported parameter contracts are excluded. At least one read required field and one unread required field must be established; all-optional reduced contracts can reject existing callers through weak-type checks.",
-    "The single return expression may use only fixed scalar field reads, flat destructuring, literals, operators and templates. Bound destructured fields count as reads even when their local aliases are unused. Whole-object escape, identity, helper calls, mutation, closures, reflection, serialization, dynamic keys, implicit Object capabilities and JSX are unsupported. Unknown semantic information causes abstention. Findings outside the fix proof remain manual; this is not a requirement to minimize every object or discard useful producer fields."
+    "Only anonymous inline contracts made of broad string, number, boolean or bigint property types are supported. Fields may be plain or readonly; the consumer body must still prove read-only usage. Retained field modifiers and optional members are preserved. Named domain contracts, brands, literal discriminants, classes, methods, callbacks, indexes, mapped types and imported parameter contracts are excluded. At least one read required field and one unread required field must be established; all-optional reduced contracts can reject existing callers through weak-type checks.",
+    "The single return expression may use only fixed scalar field reads, flat destructuring, literals, operators, templates and scalar calls to same-file implemented top-level functions or raw const arrows with an explicit return annotation. These calls require one native resolved declaration, no generic or predicate signature, scalar arguments/result and complete active native checking of the local implementation file. Their helper bodies need not be pure because only scalar values cross the call and only an erased parameter annotation changes. Imported, aliased, ambient, overloaded, optional, spread and member calls remain unsupported. Bound destructured fields count as reads even when their local aliases are unused. Whole-object escape, identity, mutation, closures, reflection, serialization, dynamic keys, implicit Object capabilities and JSX are unsupported. Unknown semantic information causes abstention. Findings outside the fix proof remain manual; this is not a requirement to minimize every object or discard useful producer fields."
   ],
   examples: [
     { id: "unused-required-field", title: "A private name consumer unnecessarily requires email", outcome: "match", files: [{ path: "src/case.ts", source: EXAMPLE2 }, CONFIG2], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: EXAMPLE2.replace("readonly email: string;", "") }] },
-    { id: "used-fields", title: "Every required dependency is read", outcome: "no-match", files: [{ path: "src/case.ts", source: EXAMPLE2.replace("return user.name;", "return user.name + user.email;") }, CONFIG2], focusPath: "src/case.ts", expectedCount: 0, public: true }
+    { id: "used-fields", title: "Every required dependency is read", outcome: "no-match", files: [{ path: "src/case.ts", source: EXAMPLE2.replace("return user.name;", "return user.name + user.email;") }, CONFIG2], focusPath: "src/case.ts", expectedCount: 0, public: true },
+    { id: "scalar-helper", scenarioId: "local-scalar-helper", title: "Only the name crosses a local scalar helper call", outcome: "match", files: [{ path: "src/case.ts", source: HELPER_EXAMPLE }, CONFIG2], focusPath: "src/case.ts", expectedCount: 1, public: true, fixedFiles: [{ path: "src/case.ts", source: HELPER_EXAMPLE.replace("email: string;", "") }] },
+    { id: "helper-and-other-field", scenarioId: "local-scalar-helper", title: "The consumer still requires a separately read field", outcome: "no-match", files: [{ path: "src/case.ts", source: HELPER_EXAMPLE.replace("return formatName(user.name);", "return formatName(user.name) + user.email;") }, CONFIG2], focusPath: "src/case.ts", expectedCount: 0, public: true }
   ]
 };
 function inlineFields(node) {
   const fields = /* @__PURE__ */ new Map();
   for (const member3 of node.members) {
-    if (!ts6.isPropertySignature(member3) || !member3.name || !ts6.isIdentifier(member3.name) && !ts6.isStringLiteralLike(member3.name) || member3.modifiers?.length !== 1 || member3.modifiers[0]?.kind !== ts6.SyntaxKind.ReadonlyKeyword || !primitiveKeyword(member3.type)) return null;
+    if (!ts8.isPropertySignature(member3) || !member3.name || !ts8.isIdentifier(member3.name) && !ts8.isStringLiteralLike(member3.name) || (member3.modifiers?.length ?? 0) > 1 || member3.modifiers?.some((modifier) => modifier.kind !== ts8.SyntaxKind.ReadonlyKeyword) || !primitiveKeyword(member3.type)) return null;
     const key = member3.name.text;
     if (fields.has(key)) return null;
     fields.set(key, !member3.questionToken);
@@ -839,7 +937,7 @@ var prefer_minimal_parameter_contract_default = createRule({
   name: "prefer-minimal-parameter-contract",
   documentation: PREFER_MINIMAL_PARAMETER_CONTRACT_DOCUMENTATION,
   meta: { type: "suggestion", fixable: "code", docs: { description: PREFER_MINIMAL_PARAMETER_CONTRACT_DOCUMENTATION.summary }, schema: [], messages: {
-    minimal: "This private consumer reads only {{used}} but also requires {{unused}}. Review a smaller readonly consumer contract; preserve the original runtime object and producer type."
+    minimal: "This private consumer reads only {{used}} but also requires {{unused}}. Review a smaller consumer contract; preserve the original runtime object and producer type."
   } },
   defaultOptions: [],
   create(context) {
@@ -858,18 +956,20 @@ var prefer_minimal_parameter_contract_default = createRule({
       "Program:exit"() {
         if (dynamic || !candidates.length) return;
         const services = ESLintUtils3.getParserServices(context);
+        const source = currentNativeSource(context.sourceCode, services);
+        if (!source) return;
         const checker = services.program.getTypeChecker();
-        const exports = exportedSymbols(services.esTreeNodeToTSNodeMap.get(context.sourceCode.ast), checker);
+        const exports = exportedSymbols(source, checker);
         for (const candidate2 of candidates) {
-          const consumer = privateScalarConsumer(candidate2, context.sourceCode, services, exports);
+          const consumer = privateScalarConsumer(candidate2, context.sourceCode, services, exports, true);
           const annotation = consumer?.parameter.type;
-          if (!consumer || !annotation || !ts6.isTypeLiteralNode(annotation)) continue;
+          if (!consumer || !annotation || !ts8.isTypeLiteralNode(annotation)) continue;
           const fields = inlineFields(annotation);
           if (!fields || [...consumer.reads].some((key) => !fields.has(key)) || ![...consumer.reads].some((key) => fields.get(key))) continue;
           const unused = [...fields].filter(([key, required]) => required && !consumer.reads.has(key)).map(([key]) => key).sort();
           if (!unused.length) continue;
           const reportNode = services.tsNodeToESTreeNodeMap.get(annotation);
-          const removed = annotation.members.filter((member3) => ts6.isPropertySignature(member3) && member3.name && (ts6.isIdentifier(member3.name) || ts6.isStringLiteralLike(member3.name)) && unused.includes(member3.name.text)).map((member3) => ({ start: member3.getStart(), end: member3.getEnd() }));
+          const removed = annotation.members.filter((member3) => ts8.isPropertySignature(member3) && member3.name && (ts8.isIdentifier(member3.name) || ts8.isStringLiteralLike(member3.name)) && unused.includes(member3.name.text)).map((member3) => ({ start: member3.getStart(), end: member3.getEnd() }));
           const fix = validConsumerFixCalls(candidate2, consumer.parameter, context.sourceCode, services) ? minimalConsumerFix(context.sourceCode, reportNode, removed) : null;
           context.report({ node: reportNode, messageId: "minimal", data: { used: [...consumer.reads].sort().join(", "), unused: unused.join(", ") }, fix });
         }
@@ -880,7 +980,282 @@ var prefer_minimal_parameter_contract_default = createRule({
 
 // src/rules/no-excess-jsx-props.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES8, ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
-import ts7 from "typescript";
+import ts10 from "typescript";
+
+// src/rules/_ordinary-object-effects.ts
+import ts9 from "typescript";
+var ANALYSES = /* @__PURE__ */ new WeakMap();
+var MAX_ALIAS_DEPTH = 64;
+var MAX_SOURCE_GRAPH = 128;
+var GLOBAL_IDENTITIES = [["Object", "object"], ["Reflect", "reflect"], ["globalThis", "globalThis"], ["eval", "dynamic"], ["Function", "dynamic"]];
+var OBJECT_REFLECTION = /* @__PURE__ */ new Set([
+  "assign",
+  "defineProperty",
+  "defineProperties",
+  "freeze",
+  "seal",
+  "preventExtensions",
+  "setPrototypeOf",
+  "getPrototypeOf",
+  "getOwnPropertyDescriptor",
+  "getOwnPropertyDescriptors"
+]);
+function ordinaryObjectEffects(program, source) {
+  let analysis = ANALYSES.get(program);
+  if (!analysis) {
+    analysis = programFacts(program);
+    ANALYSES.set(program, analysis);
+  }
+  const known2 = analysis.roots.get(source);
+  if (known2 !== void 0) return known2;
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [source];
+  while (queue.length) {
+    const current = queue.pop();
+    if (!current || visited.has(current)) continue;
+    if (analysis.roots.get(current) || visited.size >= MAX_SOURCE_GRAPH) {
+      analysis.roots.set(source, true);
+      return true;
+    }
+    visited.add(current);
+    const facts = fileFacts(current, analysis);
+    if (facts.unsafe || facts.jsx && !standardJSXRuntime(current, analysis) || analysis.aliasValues.has(current) && !checkedNativeSource(program, current)) {
+      analysis.roots.set(source, true);
+      return true;
+    }
+    queue.push(...facts.imports, ...analysis.importers.get(current) ?? []);
+  }
+  for (const file of visited) analysis.roots.set(file, false);
+  return false;
+}
+function programFacts(program) {
+  const checker = program.getTypeChecker();
+  const globals = /* @__PURE__ */ new Map();
+  for (const [name, identity2] of GLOBAL_IDENTITIES) {
+    const symbol = checker.resolveName(name, void 0, ts9.SymbolFlags.Value, false);
+    if (symbol) globals.set(symbol, identity2);
+  }
+  const importers = /* @__PURE__ */ new Map();
+  const analysis = { program, checker, globals, importers, aliasValues: /* @__PURE__ */ new WeakSet(), jsxRuntimes: /* @__PURE__ */ new WeakMap(), files: /* @__PURE__ */ new WeakMap(), roots: /* @__PURE__ */ new WeakMap() };
+  for (const source of program.getSourceFiles()) {
+    for (const dependency of fileFacts(source, analysis).imports) {
+      let parents = importers.get(dependency);
+      if (!parents) {
+        parents = /* @__PURE__ */ new Set();
+        importers.set(dependency, parents);
+      }
+      parents.add(source);
+    }
+  }
+  return analysis;
+}
+function fileFacts(source, analysis) {
+  let facts = analysis.files.get(source);
+  if (!facts) {
+    facts = sourceFacts(source, analysis);
+    analysis.files.set(source, facts);
+  }
+  return facts;
+}
+function sourceFacts(source, analysis) {
+  if (source.isDeclarationFile) return { unsafe: true, imports: [], jsx: false };
+  const references = [];
+  const imports = [];
+  let unsafe = analysis.program.isSourceFileFromExternalLibrary(source);
+  let jsx = false;
+  const visit = (node) => {
+    if (ts9.isInterfaceDeclaration(node) || ts9.isTypeAliasDeclaration(node) || ts9.isTypeLiteralNode(node) || ts9.isTypeQueryNode(node) || ts9.isTypeReferenceNode(node) || ts9.isImportTypeNode(node) || ts9.isTypeParameterDeclaration(node) || ts9.isHeritageClause(node) && node.token === ts9.SyntaxKind.ImplementsKeyword) return;
+    jsx ||= ts9.isJsxElement(node) || ts9.isJsxSelfClosingElement(node) || ts9.isJsxFragment(node);
+    const dependency = moduleEffect(node, imports, analysis);
+    if (dependency !== void 0) unsafe ||= dependency;
+    if (ts9.isImportDeclaration(node) || ts9.isExportDeclaration(node) && (node.isTypeOnly || node.moduleSpecifier) || ts9.isExportSpecifier(node) && node.isTypeOnly) return;
+    if (!unsafe) {
+      if (ts9.isIdentifier(node) || ts9.isPropertyAccessExpression(node) || ts9.isElementAccessExpression(node)) references.push(node);
+      unsafe ||= runtimeEffect(node, analysis);
+    }
+    ts9.forEachChild(node, visit);
+  };
+  visit(source);
+  if (unsafe) return { unsafe, imports, jsx };
+  for (const node of references) {
+    if (reflectiveMember(node, analysis)) unsafe = true;
+    const value = identity(node, analysis);
+    if (value === "incomplete" || value === "dynamic" || protectedIdentity(value) && !containedUse(node)) unsafe = true;
+  }
+  return { unsafe, imports, jsx };
+}
+function moduleEffect(node, imports, analysis) {
+  if (ts9.isImportDeclaration(node) || ts9.isExportDeclaration(node)) return !moduleDependency(node, imports, analysis);
+  if (!ts9.isCallExpression(node) || node.expression.kind !== ts9.SyntaxKind.ImportKeyword) return void 0;
+  const specifier = node.arguments[0];
+  const resolved = specifier && ts9.isStringLiteralLike(specifier) && resolvedDependency(specifier, imports, analysis);
+  return node.arguments.length !== 1 || !resolved;
+}
+function runtimeEffect(node, analysis) {
+  if (node.kind === ts9.SyntaxKind.ThisKeyword || node.kind === ts9.SyntaxKind.SuperKeyword || ts9.isMetaProperty(node)) return true;
+  if (ts9.isVariableDeclaration(node)) return !node.initializer;
+  if (ts9.isFunctionDeclaration(node)) return !node.body;
+  if (ts9.isForOfStatement(node) || ts9.isForInStatement(node) || ts9.isNewExpression(node) || ts9.isTaggedTemplateExpression(node)) return true;
+  if (!ts9.isCallExpression(node)) return mutationEffect(node, analysis);
+  return node.expression.kind !== ts9.SyntaxKind.ImportKeyword;
+}
+function mutationEffect(node, analysis) {
+  if (ts9.isBinaryExpression(node) && node.operatorToken.kind >= ts9.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts9.SyntaxKind.LastAssignment) return unsafeTarget(node.left, analysis);
+  if (ts9.isDeleteExpression(node)) return unsafeTarget(node.expression, analysis);
+  return (ts9.isPrefixUnaryExpression(node) || ts9.isPostfixUnaryExpression(node)) && (node.operator === ts9.SyntaxKind.PlusPlusToken || node.operator === ts9.SyntaxKind.MinusMinusToken) && unsafeTarget(node.operand, analysis);
+}
+function identity(node, analysis, active = /* @__PURE__ */ new Set()) {
+  const value = unassertedValue(node);
+  if (active.has(value) || active.size >= MAX_ALIAS_DEPTH) return "incomplete";
+  active.add(value);
+  let result = "unknown";
+  if (ts9.isObjectLiteralExpression(value) || ts9.isArrayLiteralExpression(value)) result = "fresh";
+  else if (ts9.isIdentifier(value)) result = identifierIdentity(value, analysis, active);
+  else if (ts9.isPropertyAccessExpression(value) || ts9.isElementAccessExpression(value)) result = memberIdentity(value, analysis, active);
+  active.delete(value);
+  return result;
+}
+function identifierIdentity(value, analysis, active) {
+  const parent = value.parent;
+  if (nonValueName(value)) return "unknown";
+  let symbol = ts9.isShorthandPropertyAssignment(parent) && parent.name === value ? analysis.checker.getShorthandAssignmentValueSymbol(parent) : analysis.checker.getSymbolAtLocation(value);
+  const alias = symbol !== void 0 && (symbol.flags & ts9.SymbolFlags.Alias) !== 0;
+  if (symbol && alias) symbol = analysis.checker.getAliasedSymbol(symbol);
+  if (symbol && analysis.checker.isUnknownSymbol(symbol)) return "incomplete";
+  if (!symbol || (symbol.flags & ts9.SymbolFlags.Value) === 0) {
+    const erasedBinding = ts9.isModuleDeclaration(parent) && parent.name === value || ts9.isExportSpecifier(parent) && symbol !== void 0 && (symbol.flags & (ts9.SymbolFlags.Type | ts9.SymbolFlags.Namespace)) !== 0;
+    return erasedBinding ? "unknown" : "incomplete";
+  }
+  if (alias) analysis.aliasValues.add(value.getSourceFile());
+  return runtimeBindingIdentity(value, symbol, alias, analysis, active);
+}
+function runtimeBindingIdentity(value, symbol, alias, analysis, active) {
+  const parent = value.parent;
+  if (symbol.declarations?.some(ts9.isModuleDeclaration)) {
+    return ts9.isModuleDeclaration(parent) && parent.name === value && (ts9.getCombinedModifierFlags(parent) & ts9.ModifierFlags.Ambient) === 0 ? "unknown" : "incomplete";
+  }
+  if ((symbol.flags & ts9.SymbolFlags.Property) !== 0) return "unknown";
+  if ((symbol.flags & ts9.SymbolFlags.ConstEnum) !== 0) return "incomplete";
+  const global = analysis.globals.get(symbol);
+  if (global !== void 0) return global;
+  const declaration = symbol.valueDeclaration;
+  if (declaration && !alias && declaration.getSourceFile() !== value.getSourceFile()) return "incomplete";
+  if (declaration && (declaration.getSourceFile().isDeclarationFile || (ts9.getCombinedModifierFlags(declaration) & ts9.ModifierFlags.Ambient) !== 0)) return "incomplete";
+  const initializer = constInitializer(declaration);
+  return initializer ? identity(initializer, analysis, active) : "unknown";
+}
+function nonValueName(value) {
+  const parent = value.parent;
+  if ((ts9.isPropertyAccessExpression(parent) || ts9.isPropertyAssignment(parent) || ts9.isJsxAttribute(parent) || ts9.isEnumDeclaration(parent) || ts9.isEnumMember(parent)) && parent.name === value) return true;
+  if (ts9.isBindingElement(parent) && parent.propertyName === value) return true;
+  if ((ts9.isLabeledStatement(parent) || ts9.isBreakStatement(parent) || ts9.isContinueStatement(parent)) && parent.label === value) return true;
+  if (ts9.isJsxNamespacedName(parent)) return true;
+  return (ts9.isJsxOpeningElement(parent) || ts9.isJsxSelfClosingElement(parent) || ts9.isJsxClosingElement(parent)) && parent.tagName === value && (/^[a-z]/u.test(value.text) || value.text.includes("-"));
+}
+function memberIdentity(value, analysis, active) {
+  const base = identity(value.expression, analysis, active);
+  if (base === "incomplete") return base;
+  const key = memberKey(value);
+  if (base === "object" && key === "prototype") return "prototype";
+  if (base !== "globalThis" || key === void 0) return "unknown";
+  const symbol = analysis.checker.resolveName(key, void 0, ts9.SymbolFlags.Value, false);
+  return symbol && analysis.globals.get(symbol) || "incomplete";
+}
+function memberKey(node) {
+  if (ts9.isPropertyAccessExpression(node)) return node.name.text;
+  const key = node.argumentExpression && unassertedValue(node.argumentExpression);
+  return key && (ts9.isStringLiteralLike(key) || ts9.isNumericLiteral(key)) ? key.text : void 0;
+}
+function protectedIdentity(value) {
+  return value === "object" || value === "reflect" || value === "prototype" || value === "globalThis" || value === "dynamic";
+}
+function containedUse(node) {
+  const value = expressionUse(node);
+  const parent = value.parent;
+  if (!parent) return false;
+  if ((ts9.isPropertyAccessExpression(parent) || ts9.isElementAccessExpression(parent)) && parent.expression === value) return memberKey(parent) !== void 0;
+  if (ts9.isVariableDeclaration(parent) && parent.name === value) return true;
+  if (ts9.isVariableDeclaration(parent) && parent.initializer === value) {
+    const statement = parent.parent.parent;
+    return constInitializer(parent) !== void 0 && ts9.isIdentifier(parent.name) && (!ts9.isVariableStatement(statement) || !statement.modifiers?.some((modifier) => modifier.kind === ts9.SyntaxKind.ExportKeyword));
+  }
+  return false;
+}
+function expressionUse(node) {
+  let value = node;
+  while (value.parent && unassertedValue(value.parent) === unassertedValue(value)) value = value.parent;
+  return value;
+}
+function unsafeTarget(node, analysis) {
+  const value = unassertedValue(node);
+  if (ts9.isIdentifier(value)) return protectedIdentity(identity(value, analysis));
+  if (ts9.isPropertyAccessExpression(value) || ts9.isElementAccessExpression(value)) return identity(value.expression, analysis) !== "fresh";
+  return true;
+}
+function reflectiveMember(node, analysis) {
+  if (!ts9.isPropertyAccessExpression(node) && !ts9.isElementAccessExpression(node)) return false;
+  const base = identity(node.expression, analysis);
+  const key = memberKey(node);
+  return base === "reflect" || base === "object" && (key === void 0 || OBJECT_REFLECTION.has(key));
+}
+function moduleDependency(node, imports, analysis) {
+  if (ts9.isImportDeclaration(node) && node.importClause?.isTypeOnly || ts9.isExportDeclaration(node) && node.isTypeOnly) return true;
+  const clause = ts9.isImportDeclaration(node) ? node.importClause?.namedBindings : node.exportClause;
+  const erasesNamedBindings = !analysis.program.getCompilerOptions().verbatimModuleSyntax;
+  if (erasesNamedBindings && ts9.isImportDeclaration(node) && clause && ts9.isNamedImports(clause) && !node.importClause?.name && clause.elements.length && clause.elements.every((item) => item.isTypeOnly)) return true;
+  if (erasesNamedBindings && clause && ts9.isNamedExports(clause) && clause.elements.length && clause.elements.every((item) => item.isTypeOnly)) return true;
+  if (!node.moduleSpecifier) return true;
+  return resolvedDependency(node.moduleSpecifier, imports, analysis);
+}
+function resolvedDependency(specifier, imports, analysis) {
+  const symbol = analysis.checker.getSymbolAtLocation(specifier);
+  const declarations = symbol?.declarations;
+  if (!declarations?.length) return false;
+  let resolved = true;
+  for (const declaration of declarations) {
+    if (!ts9.isSourceFile(declaration)) {
+      resolved = false;
+      continue;
+    }
+    imports.push(declaration);
+    if (declaration.isDeclarationFile || analysis.program.isSourceFileFromExternalLibrary(declaration)) resolved = false;
+  }
+  return resolved;
+}
+function standardJSXRuntime(source, analysis) {
+  const known2 = analysis.jsxRuntimes.get(source);
+  if (known2 !== void 0) return known2;
+  const standard = analysis.program.getSourceFile(source.fileName) === source && declaredJSXRuntime(source, analysis);
+  analysis.jsxRuntimes.set(source, standard);
+  return standard;
+}
+function declaredJSXRuntime(source, analysis) {
+  const mode = analysis.program.getCompilerOptions().jsx;
+  const name = mode === ts9.JsxEmit.ReactJSX ? "react/jsx-runtime" : mode === ts9.JsxEmit.ReactJSXDev ? "react/jsx-dev-runtime" : void 0;
+  if (name === void 0) return false;
+  const specifier = implicitJSXImport(source, name);
+  const declarations = specifier && analysis.checker.getSymbolAtLocation(specifier)?.declarations;
+  return declarations !== void 0 && declarations.length > 0 && declarations.every((declaration) => declaredReactRuntime(declaration, name, analysis.program));
+}
+function implicitJSXImport(source, name) {
+  const imports = source.imports;
+  if (!Array.isArray(imports)) return void 0;
+  let selected;
+  for (const node of imports) {
+    if (!node || !ts9.isStringLiteral(node) || node.text !== name || !node.parent || !ts9.isImportDeclaration(node.parent) || node.parent.moduleSpecifier !== node || node.parent.parent !== source || source.statements.includes(node.parent) || node.getSourceFile() !== source) continue;
+    if (selected) return void 0;
+    selected = node;
+  }
+  return selected;
+}
+function declaredReactRuntime(declaration, name, program) {
+  const source = declaration.getSourceFile();
+  if (!source.isDeclarationFile || program.getSourceFile(source.fileName) !== source) return false;
+  if (ts9.isSourceFile(declaration)) return program.isSourceFileFromExternalLibrary(source);
+  return ts9.isModuleDeclaration(declaration) && declaration.parent === source && ts9.isStringLiteral(declaration.name) && declaration.name.text === name;
+}
+
+// src/rules/no-excess-jsx-props.ts
 var EXAMPLE_TSCONFIG = { path: "tsconfig.json", source: '{"compilerOptions":{"strict":true,"target":"ESNext","module":"ESNext","moduleResolution":"Bundler","jsx":"react-jsx"}}' };
 var EXAMPLE_JSX = { path: "jsx.d.ts", source: 'declare module "react/jsx-runtime" { export namespace JSX { interface Element {} interface IntrinsicElements {span: {children?: unknown}} } }' };
 var NO_EXCESS_JSX_PROPS_DOCUMENTATION = {
@@ -891,23 +1266,58 @@ var NO_EXCESS_JSX_PROPS_DOCUMENTATION = {
   defaultLevel: "warning",
   autofix: "none",
   limitations: [
+    "The created JSX value must initialize a private actual const binding. Only unused values or same-function-scope fixed reads of already proven consumed scalar props are supported. Enclosing invocations must have no runtime argument or arguments-object dependency, async/generator suspension, or unproved captured values. Unused simple arguments and captured scalar data reuse the existing provenance proof; destructured/default/rest arguments remain unsupported. Exported, returned, aliased, captured, aggregated or forwarded elements, whole-props access, opaque calls, type observations and writes abstain. A caller can mutate production React props after creation even when development React freezes them; initial source provenance alone is insufficient. This restriction intentionally excludes ordinary exported and rendered elements until their consumers can be proved.",
+    "The rule abstains when the receiving or calling project runtime dependency context contains a known ordinary Object-prototype effect or exposure, native eval/Function capabilities, any explicit call, constructor or tagged-template invocation, for-of or for-in iteration, an ambient or uninitialized value declaration or a declaration-file value read, an unresolved lexical value (including a shorthand or a type-only name used as a value), an erased const-enum value without a runtime binding proof, an opaque globalThis member, an implicit this/super/module-metadata capability, an extracted reflective method, or a member-write target not proven to be a fresh unrelated object/array literal. Callable and class metadata writes, including through erased const aliases, abstain: runtime metadata can observe omitted fields even when it is absent from the native JSX contract. Native shorthand value symbols preserve global capability identity instead of trusting a newly created property symbol. Property keys, control-flow labels, intrinsic JSX names and erased type positions do not evaluate lexical values; their missing symbols or Any types do not alone veto a finding. Native ESM imports/re-exports and literal dynamic imports are followed in both dependency and known-importer directions, including other dependencies of those importers and resolved bare path aliases; whole-clause import type/export type forms are skipped. Import-equals and other loader forms are unsupported. Per-specifier type imports/exports retain their runtime edges when native verbatimModuleSyntax emit keeps an empty import/export. Unresolved runtime imports and declaration-only or external-library runtime imports abstain. Literal dynamic imports retain their module-resolution proof. External code outside the analyzed project context and standard library implementations remain opaque; standard ordinary Object built-ins are assumed. Connected runtime dependency contexts beyond 128 files or const-alias proofs beyond 64 steps abstain. Safe reflective code may therefore be excluded. This finite known-effect exclusion does not prove universal prototype pristineness.",
     "Requires parser-owned TypeScript information, a strict module implementation, a complete Object base, a self-closing identifier tag with one plain object-literal spread and no other attributes, and one nongeneric implemented synchronous arrow receiver with a resolved finite props surface. Sibling attributes or children could override the proven source values. Unknown, opaque, union, overloaded, generic, intrinsic and class receivers are excluded.",
     "Mapped types, index signatures, namespace/value-derived contracts, unresolved inherited or computed receiver keys, nonliteral computed source keys, nested spreads, accessors and explicit __proto__ keys are excluded. Source type properties alone do not prove enumerable own runtime keys. key, ref, React's __self/__source development metadata and TypeScript's hyphenated JSX attribute names are preserved.",
     "Native member lookup includes inherited, optional, readonly and implicit Object capabilities. The rule reports runtime keys outside the contract; it does not infer unused component fields, demand smaller public APIs, or erase producer type information.",
-    "Requires a single returned view made from intrinsic JSX, literals and scalar parameter reads/operators. Free runtime values, helper calls, callbacks, object-valued consumed fields, custom tags, rest/spread, reflection and dynamic access prevent a finding; indirect element.props aliases cannot be inferred safe. Every inspected or destructured root field must be an own source-literal key; an omitted field could invoke an inherited getter. Bound/read source values must have concrete scalar types without undefined, Any or unknown after removing assertions; undefined can activate runtime defaults. Opaque HOC and declaration-file signatures are unsupported rather than assumed to ignore extra fields.",
+    "Runtime alias references require active native checking of each reached local implementation, with no located syntax or semantic errors. Checking disabled by noCheck or native-shaped TypeScript suppression directives is unavailable evidence. JavaScript, declaration/default/external-library files, foreign SourceFile objects and project-reference programs are unsupported for this alias proof. Importer indexing does not request full semantic checks; reached files reuse the parser-owned Program's diagnostic caches. Unlocated/global diagnostics are not treated as a clean project or as proof of runtime binding presence. Namespace value reads, including merged and const-enum-only namespace carriers, abstain because a ValueModule symbol can survive erased runtime output without a native error. Pure type namespaces and nonambient namespace declaration names remain non-value positions; explicit ambient namespace declarations retain their existing exclusion. A non-import-alias value declared in another source also abstains: inclusion in the type Program does not establish that a script/global implementation executes or that an ambient binding is supplied as a data property. Native standard global identities retain their existing assumptions.",
+    "Requires a single returned view made from intrinsic JSX, literals and scalar parameter reads/operators. JSX objects may be rendered as children or returned branches, but cannot be operands of scalar coercions or intrinsic attribute values. Free runtime values, helper calls, callbacks, object-valued consumed fields, custom tags, rest/spread, reflection and dynamic access prevent a finding; indirect element.props aliases cannot be inferred safe. Every inspected or destructured root field must be an own source-literal key; an omitted field could invoke an inherited getter. Bound/read source values require concrete scalar types without undefined, Any or unknown and runtime primitive provenance: literals, operators/templates with proven primitive operands, proven conditional tests and branches, or local immutable const initializers after removing assertions. Direct own fields of a same-file const object literal are supported only when every object reference is a fixed field value in a direct object initializer, inline JSX spread, JSX expression or local binding, with no direct eval. Mutation, accessors, method receivers, dynamic keys, reflection, whole-object aliases and exports abstain. Opaque calls, getters, parameters, mutable bindings and imported source values abstain even when annotated as scalars. Unproven source paths beyond 64 expressions abstain as an analysis resource limit. Only successful value proofs are memoized. An alias or assertion cannot turn an object into a primitive; undefined can activate runtime defaults. Opaque HOC and declaration-file signatures remain unsupported.",
     "The actual tag must resolve through immutable identifier aliases to a const arrow initializer. Constructible ordinary functions, mutable, member, proxy, call-produced and asserted receiver values are excluded even when their callable type resembles a known implementation; inherited runtime metadata can change ordinary function dispatch. Exactly one actual parameter and no explicit this parameter are supported.",
+    "Reached files containing actual JSX additionally require their compiler-owned implicit runtime import and the native module symbol's declaration owners. Known non-declaration runtime implementations are unsupported even when their bodies have no ordinary Object effects: a custom factory can reinterpret forwarded fields. External declaration files and owned top-level ambient module declarations in declaration files retain the explicit standard-React library assumption; those declarations do not prove the actual runtime JavaScript identity. Missing or ambiguous internal import metadata, missing native symbols, foreign owners and local nonambient declaration-module sources abstain. Non-JSX dependencies do not acquire a runtime edge merely because the compiler records an unused synthetic JSX import. Runtime rebinding outside the compiler-visible module context remains opaque, not validated by this proof.",
     "Requires target ES2015 or newer, explicit native ES-module output and the standard React automatic JSX runtime (react-jsx or react-jsxdev). Downlevel arrows become constructible functions; CommonJS exports remain mutable. Preserve/classic JSX, custom factories, namespaces, import sources and per-file JSX directives are unsupported. Imported library implementations and cross-project source redirects are opaque; relative imports within this program remain supported."
   ],
   references: ["https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-props-no-spreading.md"],
   examples: [
     { id: "excess-runtime-field", title: "An unrelated field is forwarded at runtime", outcome: "match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; const Avatar = ({ displayName }: { displayName: string }) => <span>{displayName}</span>;\nconst avatar = <Avatar {...{ displayName: 'Ada', email: 'ada@example.test' }} />;" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 1, public: true },
-    { id: "explicit-fields", title: "Forward only the declared field", outcome: "no-match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; const Avatar = ({ displayName }: { displayName: string }) => <span>{displayName}</span>;\nconst avatar = <Avatar displayName='Ada' />;" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 0, public: true }
+    { id: "explicit-fields", title: "Forward only the declared field", outcome: "no-match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; const Avatar = ({ displayName }: { displayName: string }) => <span>{displayName}</span>;\nconst avatar = <Avatar displayName='Ada' />;" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 0, public: true },
+    { id: "asserted-source-alias", scenarioId: "source-provenance", title: "An asserted alias can still observe forwarded data", outcome: "no-match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; let element: any; const opaque = {toString() {return element.props.email;}}; const name = opaque as unknown as string; const Avatar = ({displayName}: {displayName: string}) => <span>{`${displayName}`}</span>; element = <Avatar {...{displayName: name, email: 'needed'}}/>;" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 0, public: true },
+    { id: "literal-source-alias", scenarioId: "source-provenance", title: "A proven primitive alias preserves the finding", outcome: "match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; const name = 'Ada'; const Avatar = ({displayName}: {displayName: string}) => <span>{`${displayName}`}</span>; const element = <Avatar {...{displayName: name, email: 'unused'}}/>;" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 1, public: true },
+    { id: "inherited-runtime-hook", scenarioId: "prototype-effects", title: "An inherited runtime hook can observe forwarded data", outcome: "no-match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; let element: any; const Avatar = ({displayName}: {displayName: string}) => <span>{displayName}</span>; element = <Avatar {...{displayName: 'Ada', email: 'needed'}}/>; Object.defineProperty(Object.prototype, 'ref', {configurable: true, get() {Object.defineProperty(this, 'children', {configurable: true, value: element.props.email}); return null;}});" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 0, public: true },
+    { id: "unrelated-runtime-object", scenarioId: "prototype-effects", title: "An unrelated own-property write preserves the finding", outcome: "match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; const target = {ref: null}; target.ref = null; const Avatar = ({displayName}: {displayName: string}) => <span>{displayName}</span>; const element = <Avatar {...{displayName: 'Ada', email: 'unused'}}/>;" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 1, public: true },
+    { id: "erased-callable-metadata", scenarioId: "callable-metadata", title: "Runtime metadata can observe an omitted field", outcome: "no-match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; const target = {ref: 0}; const Avatar = ({displayName}: {displayName: string}) => <span>{displayName}</span>; (Avatar as unknown as {defaultProps: {email: string}}).defaultProps = {get email() {target.ref = 1; return 'fallback';}}; const element = <Avatar {...{displayName: 'Ada', email: 'needed'}}/>; const observation = target.ref; export {observation};" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 0, public: true },
+    { id: "unrelated-object-metadata", scenarioId: "callable-metadata", title: "An unrelated data object's metadata preserves the finding", outcome: "match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; const settings = {defaultProps: {email: 'fallback'}}; settings.defaultProps = {email: 'updated'}; const Avatar = ({displayName}: {displayName: string}) => <span>{displayName}</span>; const element = <Avatar {...{displayName: 'Ada', email: 'unused'}}/>;" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 1, public: true },
+    { id: "consumed-scalar-inspection", scenarioId: "created-value", title: "A private element exposes only its consumed scalar", outcome: "match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; const Avatar = ({displayName}: {displayName: string}) => <span>{displayName}</span>; const element = <Avatar {...{displayName: 'Ada', email: 'unused'}}/>; const summary = {displayName: (element as {props: {displayName: string}}).props.displayName}; export {summary};" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 1, public: true },
+    { id: "opaque-element-consumer", scenarioId: "created-value", title: "An opaque consumer can observe or mutate element props", outcome: "no-match", files: [EXAMPLE_JSX, { path: "src/avatar.tsx", source: "export {}; declare function inspect(value: unknown): void; const Avatar = ({displayName}: {displayName: string}) => <span>{displayName}</span>; const element = <Avatar {...{displayName: 'Ada', email: 'needed'}}/>; inspect(element);" }, EXAMPLE_TSCONFIG], focusPath: "src/avatar.tsx", expectedCount: 0, public: true }
   ]
 };
 var RESERVED_PROPS = /* @__PURE__ */ new Set(["key", "ref", "__self", "__source"]);
-var ESM_MODULES = /* @__PURE__ */ new Set([ts7.ModuleKind.ES2015, ts7.ModuleKind.ES2020, ts7.ModuleKind.ES2022, ts7.ModuleKind.ESNext]);
+var ESM_MODULES = /* @__PURE__ */ new Set([ts10.ModuleKind.ES2015, ts10.ModuleKind.ES2020, ts10.ModuleKind.ES2022, ts10.ModuleKind.ESNext]);
 var JSX_DIRECTIVE = /@jsx(?:ImportSource|Runtime|Frag)?(?:\s|$)/iu;
-function literalFields(node) {
+var MAX_VALUE_DEPTH = 64;
+var PRIMITIVE_OPERATORS = /* @__PURE__ */ new Set([
+  ts10.SyntaxKind.PlusToken,
+  ts10.SyntaxKind.MinusToken,
+  ts10.SyntaxKind.AsteriskToken,
+  ts10.SyntaxKind.SlashToken,
+  ts10.SyntaxKind.PercentToken,
+  ts10.SyntaxKind.AsteriskAsteriskToken,
+  ts10.SyntaxKind.LessThanToken,
+  ts10.SyntaxKind.LessThanEqualsToken,
+  ts10.SyntaxKind.GreaterThanToken,
+  ts10.SyntaxKind.GreaterThanEqualsToken,
+  ts10.SyntaxKind.EqualsEqualsEqualsToken,
+  ts10.SyntaxKind.ExclamationEqualsEqualsToken,
+  ts10.SyntaxKind.EqualsEqualsToken,
+  ts10.SyntaxKind.ExclamationEqualsToken,
+  ts10.SyntaxKind.AmpersandToken,
+  ts10.SyntaxKind.BarToken,
+  ts10.SyntaxKind.CaretToken,
+  ts10.SyntaxKind.LessThanLessThanToken,
+  ts10.SyntaxKind.GreaterThanGreaterThanToken,
+  ts10.SyntaxKind.GreaterThanGreaterThanGreaterThanToken
+]);
+function plainLiteralFields(node) {
   const fields = /* @__PURE__ */ new Map();
   for (const property of node.properties) {
     if (property.type !== AST_NODE_TYPES8.Property || property.kind !== "init") return null;
@@ -917,20 +1327,27 @@ function literalFields(node) {
     else if (key.type === AST_NODE_TYPES8.Literal && (typeof key.value === "string" || typeof key.value === "number")) name = String(key.value);
     else return null;
     if (name === "__proto__") return null;
-    if (!RESERVED_PROPS.has(name) && !name.includes("-")) fields.set(name, property);
+    fields.set(name, property);
+  }
+  return fields;
+}
+function literalFields(node) {
+  const fields = plainLiteralFields(node);
+  if (fields) {
+    for (const name of fields.keys()) if (RESERVED_PROPS.has(name) || name.includes("-")) fields.delete(name);
   }
   return fields;
 }
 function receiverReads(signature, checker) {
   const declaration = signature.getDeclaration();
-  if (!declaration || !ts7.isArrowFunction(declaration) || declaration.modifiers?.some((modifier) => modifier.kind === ts7.SyntaxKind.AsyncKeyword) || signature.thisParameter || declaration.parameters.length !== 1) return null;
+  if (!declaration || !ts10.isArrowFunction(declaration) || declaration.modifiers?.some((modifier) => modifier.kind === ts10.SyntaxKind.AsyncKeyword) || signature.thisParameter || declaration.parameters.length !== 1) return null;
   const parameter = declaration.parameters[0];
   return parameter ? scalarParameterView(parameter, declaration.body, checker) : null;
 }
 function stableReceiver(tag, signature, checker, program, overrides) {
-  if (!ts7.isIdentifier(tag)) return false;
+  if (!ts10.isIdentifier(tag)) return false;
   const initializer = immutableInitializer(tag, checker);
-  if (!initializer || initializer !== signature.getDeclaration() || !ts7.isArrowFunction(initializer)) return false;
+  if (!initializer || initializer !== signature.getDeclaration() || !ts10.isArrowFunction(initializer)) return false;
   return supportedImplementation(initializer.getSourceFile(), tag.getSourceFile(), program, overrides);
 }
 function immutableInitializer(tag, checker) {
@@ -938,37 +1355,31 @@ function immutableInitializer(tag, checker) {
   const seen = /* @__PURE__ */ new Set();
   while (symbol && !seen.has(symbol)) {
     seen.add(symbol);
-    if ((symbol.flags & ts7.SymbolFlags.Alias) !== 0) {
+    if ((symbol.flags & ts10.SymbolFlags.Alias) !== 0) {
       symbol = checker.getAliasedSymbol(symbol);
       continue;
     }
     const initializer = constInitializer(symbol.valueDeclaration);
-    if (!initializer || !ts7.isIdentifier(initializer)) return initializer;
+    if (!initializer || !ts10.isIdentifier(initializer)) return initializer;
     symbol = checker.getSymbolAtLocation(initializer);
   }
   return void 0;
 }
-function constInitializer(declaration) {
-  if (!declaration || !ts7.isVariableDeclaration(declaration) || !ts7.isVariableDeclarationList(declaration.parent) || (declaration.parent.flags & ts7.NodeFlags.Const) === 0) return void 0;
-  let initializer = declaration.initializer;
-  while (initializer && ts7.isParenthesizedExpression(initializer)) initializer = initializer.expression;
-  return initializer;
-}
 function supportedImplementation(source, caller, program, overrides) {
-  if (!ts7.isExternalModule(source) || source.impliedNodeFormat === ts7.ModuleKind.CommonJS || program.isSourceFileFromExternalLibrary(source)) return false;
+  if (!ts10.isExternalModule(source) || source.impliedNodeFormat === ts10.ModuleKind.CommonJS || program.isSourceFileFromExternalLibrary(source)) return false;
   if (source === caller) return true;
   if (program.getProjectReferences()?.length) return false;
-  if (!overrides.has(source)) overrides.set(source, (ts7.getLeadingCommentRanges(source.text, 0) ?? []).some((range) => JSX_DIRECTIVE.test(source.text.slice(range.pos, range.end))));
+  if (!overrides.has(source)) overrides.set(source, (ts10.getLeadingCommentRanges(source.text, 0) ?? []).some((range) => JSX_DIRECTIVE.test(source.text.slice(range.pos, range.end))));
   return !overrides.get(source);
 }
 function supportedJSX(options, comments) {
-  return (options.target ?? ts7.ScriptTarget.ES5) >= ts7.ScriptTarget.ES2015 && ESM_MODULES.has(options.module ?? ts7.ModuleKind.None) && (options.jsx === ts7.JsxEmit.ReactJSX || options.jsx === ts7.JsxEmit.ReactJSXDev) && !options.jsxFactory && !options.reactNamespace && (!options.jsxImportSource || options.jsxImportSource === "react") && !comments.some((comment) => JSX_DIRECTIVE.test(comment.value));
+  return (options.target ?? ts10.ScriptTarget.ES5) >= ts10.ScriptTarget.ES2015 && ESM_MODULES.has(options.module ?? ts10.ModuleKind.None) && (options.jsx === ts10.JsxEmit.ReactJSX || options.jsx === ts10.JsxEmit.ReactJSXDev) && !options.jsxFactory && !options.reactNamespace && (!options.jsxImportSource || options.jsxImportSource === "react") && !comments.some((comment) => JSX_DIRECTIVE.test(comment.value));
 }
 function receivingContract(opening, services, checker, contracts) {
   const native = services.esTreeNodeToTSNodeMap.get(opening);
-  if (!ts7.isJsxOpeningElement(native) && !ts7.isJsxSelfClosingElement(native)) return null;
+  if (!ts10.isJsxOpeningElement(native) && !ts10.isJsxSelfClosingElement(native)) return null;
   const receiver = checker.getTypeAtLocation(native.tagName);
-  const signatures = checker.getSignaturesOfType(receiver, ts7.SignatureKind.Call);
+  const signatures = checker.getSignaturesOfType(receiver, ts10.SignatureKind.Call);
   const signature = signatures[0];
   if (receiver.isUnion() || signatures.length !== 1 || !signature || signature.typeParameters?.length) return null;
   const props = checker.getContextualType(native.attributes);
@@ -976,19 +1387,132 @@ function receivingContract(opening, services, checker, contracts) {
   if (!contracts.has(props)) contracts.set(props, closedObjectContract(props, checker));
   return contracts.get(props) ? { tag: native.tagName, signature, props } : null;
 }
-function ownScalarReads(fields, reads, services, checker) {
+function ownScalarReads(fields, reads, proof) {
   for (const key of reads) {
     const field = fields.get(key);
     if (!field) return false;
-    const value = unassertedValue(services.esTreeNodeToTSNodeMap.get(field.value));
-    if (!scalarType(checker.getTypeAtLocation(value), false)) return false;
+    if (!primitiveValue(proof.services.esTreeNodeToTSNodeMap.get(field.value), proof, /* @__PURE__ */ new Set())) return false;
   }
   return true;
 }
-function unassertedValue(node) {
-  let value = node;
-  while (ts7.isParenthesizedExpression(value) || ts7.isAsExpression(value) || ts7.isTypeAssertionExpression(value) || ts7.isNonNullExpression(value) || ts7.isSatisfiesExpression(value)) value = value.expression;
-  return value;
+function primitiveValue(node, proof, active) {
+  const value = unassertedValue(node);
+  if (proof.values.has(value)) return true;
+  if (active.has(value) || active.size >= MAX_VALUE_DEPTH) return false;
+  active.add(value);
+  const result = scalarType(proof.checker.getTypeAtLocation(value), false) && primitiveResult(value, proof, active);
+  active.delete(value);
+  if (result) proof.values.add(value);
+  return result;
+}
+function primitiveResult(value, proof, active) {
+  if (ts10.isStringLiteralLike(value) || ts10.isNumericLiteral(value) || ts10.isBigIntLiteral(value) || value.kind === ts10.SyntaxKind.TrueKeyword || value.kind === ts10.SyntaxKind.FalseKeyword || value.kind === ts10.SyntaxKind.NullKeyword) return true;
+  if (ts10.isTemplateExpression(value)) return value.templateSpans.every((span) => primitiveValue(span.expression, proof, active));
+  if (ts10.isTypeOfExpression(value)) return primitiveValue(value.expression, proof, active);
+  if (ts10.isPrefixUnaryExpression(value)) return (value.operator === ts10.SyntaxKind.PlusToken || value.operator === ts10.SyntaxKind.MinusToken || value.operator === ts10.SyntaxKind.ExclamationToken || value.operator === ts10.SyntaxKind.TildeToken) && primitiveValue(value.operand, proof, active);
+  if (ts10.isConditionalExpression(value)) return primitiveValue(value.condition, proof, active) && primitiveValue(value.whenTrue, proof, active) && primitiveValue(value.whenFalse, proof, active);
+  if (ts10.isBinaryExpression(value)) {
+    return (PRIMITIVE_OPERATORS.has(value.operatorToken.kind) || RETURNED_OPERANDS.has(value.operatorToken.kind) || value.operatorToken.kind === ts10.SyntaxKind.CommaToken) && primitiveValue(value.left, proof, active) && primitiveValue(value.right, proof, active);
+  }
+  if (ts10.isPropertyAccessExpression(value) || ts10.isElementAccessExpression(value)) return primitiveMember(value, proof, active);
+  if (!ts10.isIdentifier(value)) return false;
+  const symbol = ts10.isShorthandPropertyAssignment(value.parent) ? proof.checker.getShorthandAssignmentValueSymbol(value.parent) : proof.checker.getSymbolAtLocation(value);
+  const initializer = symbol && (symbol.flags & ts10.SymbolFlags.Alias) === 0 ? constInitializer(symbol.valueDeclaration) : void 0;
+  return initializer !== void 0 && initializer.getSourceFile() === value.getSourceFile() && primitiveValue(initializer, proof, active);
+}
+function primitiveMember(node, proof, active) {
+  if (!proof.staticScope || !ts10.isIdentifier(node.expression)) return false;
+  const key = ts10.isPropertyAccessExpression(node) ? node.name.text : node.argumentExpression && (ts10.isStringLiteralLike(node.argumentExpression) || ts10.isNumericLiteral(node.argumentExpression)) ? node.argumentExpression.text : void 0;
+  const symbol = proof.checker.getSymbolAtLocation(node.expression);
+  if (!symbol || key === void 0 || (symbol.flags & ts10.SymbolFlags.Alias) !== 0) return false;
+  if (!proof.objects.has(symbol)) proof.objects.set(symbol, localObjectFields(symbol, node.getSourceFile(), proof));
+  const field = proof.objects.get(symbol)?.get(key);
+  return field !== void 0 && primitiveValue(proof.services.esTreeNodeToTSNodeMap.get(field.value), proof, active);
+}
+function localObjectFields(symbol, source, proof) {
+  const native = symbol.valueDeclaration;
+  const initial = constInitializer(native);
+  const initializer = initial && unassertedValue(initial);
+  if (!native || native.getSourceFile() !== source || !initializer || !ts10.isObjectLiteralExpression(initializer)) return null;
+  const declaration = proof.services.tsNodeToESTreeNodeMap.get(native);
+  const literal2 = proof.services.tsNodeToESTreeNodeMap.get(initializer);
+  if (declaration.type !== AST_NODE_TYPES8.VariableDeclarator || declaration.parent.kind !== "const" || declaration.id.type !== AST_NODE_TYPES8.Identifier || literal2.type !== AST_NODE_TYPES8.ObjectExpression || declaration.parent.parent.type === AST_NODE_TYPES8.ExportNamedDeclaration) return null;
+  const fields = plainLiteralFields(literal2);
+  const binding3 = proof.sourceCode.getDeclaredVariables(declaration).find((variable) => variable.defs.some((definition) => definition.type === "Variable" && definition.node === declaration));
+  if (!fields || !binding3 || binding3.defs.length !== 1 || !stableValueBinding(binding3, (reference) => {
+    if (!reference.isReadOnly() || reference.isTypeReference) return false;
+    const member3 = reference.identifier.parent;
+    return member3.type === AST_NODE_TYPES8.MemberExpression && member3.object === reference.identifier && readonlyFieldValue(member3, fields);
+  })) return null;
+  return fields;
+}
+function staticMemberKey(member3) {
+  const property = member3.property;
+  return !member3.computed && property.type === AST_NODE_TYPES8.Identifier ? property.name : property.type === AST_NODE_TYPES8.Literal && (typeof property.value === "string" || typeof property.value === "number") ? String(property.value) : void 0;
+}
+function readonlyFieldValue(member3, fields) {
+  const key = staticMemberKey(member3);
+  if (key === void 0 || !fields.has(key)) return false;
+  const parent = member3.parent;
+  if (parent.type === AST_NODE_TYPES8.Property && parent.value === member3 && parent.parent.type === AST_NODE_TYPES8.ObjectExpression) {
+    const object = parent.parent;
+    const owner = object.parent;
+    return owner.type === AST_NODE_TYPES8.JSXSpreadAttribute && owner.argument === object || owner.type === AST_NODE_TYPES8.VariableDeclarator && owner.init === object;
+  }
+  return parent.type === AST_NODE_TYPES8.JSXExpressionContainer && parent.expression === member3 || parent.type === AST_NODE_TYPES8.VariableDeclarator && parent.init === member3;
+}
+function privateElementDeclaration(opening) {
+  const value = outerExpression(opening.parent);
+  const declaration = value.parent;
+  return declaration.type === AST_NODE_TYPES8.VariableDeclarator && declaration.init === value && declaration.id.type === AST_NODE_TYPES8.Identifier && declaration.parent.kind === "const" && declaration.parent.parent.type !== AST_NODE_TYPES8.ExportNamedDeclaration ? declaration : null;
+}
+function closedElementValue(opening, declaration, fields, reads, proof) {
+  if (!proof.staticScope || !closedInvocation(opening, proof) || !constInitializer(proof.services.esTreeNodeToTSNodeMap.get(declaration))) return false;
+  const binding3 = proof.sourceCode.getDeclaredVariables(declaration).find((variable) => variable.defs.some((definition) => definition.type === "Variable" && definition.node === declaration));
+  const symbol = proof.checker.getSymbolAtLocation(proof.services.esTreeNodeToTSNodeMap.get(declaration.id));
+  if (!symbol || proof.exports.has(symbol)) return false;
+  return binding3 !== void 0 && binding3.defs.length === 1 && stableValueBinding(binding3, (reference) => {
+    if (!reference.isReadOnly() || reference.isTypeReference || reference.from.variableScope !== binding3.scope.variableScope) return false;
+    return consumedElementRead(reference.identifier, fields, reads);
+  });
+}
+function closedInvocation(node, proof) {
+  for (let scope = proof.sourceCode.getScope(node); scope; scope = scope.upper) {
+    if (scope.type !== "function") continue;
+    let closed = proof.invocations.get(scope);
+    if (closed === void 0) {
+      closed = independentInvocation(scope, proof);
+      proof.invocations.set(scope, closed);
+    }
+    if (!closed) return false;
+  }
+  return true;
+}
+function independentInvocation(scope, proof) {
+  const block = scope.block;
+  if (block.type !== AST_NODE_TYPES8.ArrowFunctionExpression && block.type !== AST_NODE_TYPES8.FunctionDeclaration && block.type !== AST_NODE_TYPES8.FunctionExpression) return false;
+  if (block.async || block.generator || scope.set.get("arguments")?.references.some((reference) => !typeOnlyReference(reference))) return false;
+  for (const parameter of block.params) {
+    if (parameter.type !== AST_NODE_TYPES8.Identifier || parameter.name === "this") return false;
+    const binding3 = scope.set.get(parameter.name);
+    if (!binding3 || binding3.references.some((reference) => !typeOnlyReference(reference))) return false;
+  }
+  return scope.through.every((reference) => {
+    if (typeOnlyReference(reference)) return true;
+    const value = outerExpression(reference.identifier);
+    const parent = value.parent;
+    const read = parent?.type === AST_NODE_TYPES8.MemberExpression && parent.object === value ? parent : value;
+    return primitiveValue(proof.services.esTreeNodeToTSNodeMap.get(read), proof, /* @__PURE__ */ new Set());
+  });
+}
+function consumedElementRead(node, fields, reads) {
+  const identifier = outerExpression(node);
+  const props = identifier.parent;
+  if (!props || props.type !== AST_NODE_TYPES8.MemberExpression || props.object !== identifier || props.optional || staticMemberKey(props) !== "props") return false;
+  const member3 = props.parent;
+  if (member3.type !== AST_NODE_TYPES8.MemberExpression || member3.object !== props || member3.optional) return false;
+  const key = staticMemberKey(member3);
+  return key !== void 0 && reads.has(key) && readonlyFieldValue(member3, fields);
 }
 var no_excess_jsx_props_default = createRule({
   name: "no-excess-jsx-props",
@@ -1007,33 +1531,63 @@ var no_excess_jsx_props_default = createRule({
     const contracts = /* @__PURE__ */ new WeakMap();
     const receivers = /* @__PURE__ */ new WeakMap();
     const overrides = /* @__PURE__ */ new WeakMap();
+    let proof;
+    let dynamic = false;
+    const candidates = [];
     let standardJSX;
+    const evaluate = (node, declaration, fields) => {
+      const keys = [...fields.keys()];
+      const opening = node.parent;
+      services ??= ESLintUtils4.getParserServices(context);
+      standardJSX ??= supportedJSX(services.program.getCompilerOptions(), context.sourceCode.getAllComments());
+      if (!standardJSX) return;
+      const checker = services.program.getTypeChecker();
+      if (objectContract2 === void 0) {
+        const object = checker.resolveName("Object", void 0, ts10.SymbolFlags.Type, false);
+        objectContract2 = object !== void 0 && closedObjectContract(checker.getDeclaredTypeOfSymbol(object), checker);
+      }
+      if (!objectContract2) return;
+      const contract = receivingContract(opening, services, checker, contracts);
+      if (!contract) return;
+      const excess = keys.filter((key) => checker.getPropertyOfType(contract.props, key) === void 0).sort();
+      if (!excess.length || !stableReceiver(contract.tag, contract.signature, checker, services.program, overrides)) return;
+      const signature = contract.signature;
+      if (!receivers.has(signature)) receivers.set(signature, receiverReads(signature, checker));
+      const reads = receivers.get(signature);
+      proof ??= {
+        checker,
+        services,
+        sourceCode: context.sourceCode,
+        staticScope: !dynamic,
+        exports: exportedSymbols(services.esTreeNodeToTSNodeMap.get(context.sourceCode.ast), checker),
+        values: /* @__PURE__ */ new WeakSet(),
+        objects: /* @__PURE__ */ new WeakMap(),
+        invocations: /* @__PURE__ */ new WeakMap()
+      };
+      if (!reads || !ownScalarReads(fields, reads, proof) || !closedElementValue(opening, declaration, fields, reads, proof)) return;
+      const implementation = signature.getDeclaration();
+      if (!implementation || ordinaryObjectEffects(services.program, contract.tag.getSourceFile()) || ordinaryObjectEffects(services.program, implementation.getSourceFile())) return;
+      context.report({ node, messageId: "excess", data: { fields: excess.join(", ") } });
+    };
     return {
       JSXSpreadAttribute(node) {
         if (node.argument.type !== AST_NODE_TYPES8.ObjectExpression) return;
-        const fields = literalFields(node.argument);
-        if (!fields?.size) return;
-        const keys = [...fields.keys()];
         const opening = node.parent;
         if (!opening.selfClosing || opening.attributes.length !== 1 || opening.name.type !== AST_NODE_TYPES8.JSXIdentifier || /^[a-z]/u.test(opening.name.name)) return;
-        services ??= ESLintUtils4.getParserServices(context);
-        standardJSX ??= supportedJSX(services.program.getCompilerOptions(), context.sourceCode.getAllComments());
-        if (!standardJSX) return;
-        const checker = services.program.getTypeChecker();
-        if (objectContract2 === void 0) {
-          const object = checker.resolveName("Object", void 0, ts7.SymbolFlags.Type, false);
-          objectContract2 = object !== void 0 && closedObjectContract(checker.getDeclaredTypeOfSymbol(object), checker);
-        }
-        if (!objectContract2) return;
-        const contract = receivingContract(opening, services, checker, contracts);
-        if (!contract) return;
-        const excess = keys.filter((key) => checker.getPropertyOfType(contract.props, key) === void 0).sort();
-        if (!excess.length || !stableReceiver(contract.tag, contract.signature, checker, services.program, overrides)) return;
-        const signature = contract.signature;
-        if (!receivers.has(signature)) receivers.set(signature, receiverReads(signature, checker));
-        const reads = receivers.get(signature);
-        if (!reads || !ownScalarReads(fields, reads, services, checker)) return;
-        context.report({ node, messageId: "excess", data: { fields: excess.join(", ") } });
+        const declaration = privateElementDeclaration(opening);
+        if (!declaration) return;
+        const fields = literalFields(node.argument);
+        if (!fields?.size) return;
+        candidates.push({ node, declaration, fields });
+      },
+      CallExpression(node) {
+        if (directEval(node)) dynamic = true;
+      },
+      "Program:exit"() {
+        if (!candidates.length) return;
+        services = ESLintUtils4.getParserServices(context);
+        if (!currentNativeSource(context.sourceCode, services)) return;
+        for (const { node, declaration, fields } of candidates) evaluate(node, declaration, fields);
       }
     };
   }
@@ -1533,7 +2087,7 @@ function isSearchParamReceiver(call, services) {
 // package.json
 var package_default = {
   name: "@sarj/eslint-plugin",
-  version: "16.32.0",
+  version: "16.32.3",
   packageManager: "npm@12.2.1",
   description: "Custom ESLint rules for hypermodern TypeScript / React / Next.js projects",
   type: "module",
@@ -1659,29 +2213,29 @@ import {
   AST_NODE_TYPES as AST_NODE_TYPES14,
   ESLintUtils as ESLintUtils6
 } from "@typescript-eslint/utils";
-import * as ts9 from "typescript";
+import * as ts12 from "typescript";
 
 // src/rules/_closed-nominal-inheritance-fix.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES13,
   ASTUtils as ASTUtils4
 } from "@typescript-eslint/utils";
-import ts8 from "typescript";
+import ts11 from "typescript";
 function closedNominalInheritanceFix(sourceCode, call, consumer, implementation, contract) {
   const source = call.getSourceFile();
   if (source.text !== sourceCode.text || source.statements.length !== 5 || sourceCode.getAllComments().length > 0 || [consumer, implementation, contract].some(
     (node) => node.getSourceFile() !== source
   ))
     return null;
-  const markers = source.statements.filter(ts8.isExportDeclaration);
+  const markers = source.statements.filter(ts11.isExportDeclaration);
   if (markers.length !== 1 || markers[0] === void 0 || !emptyModuleMarker(markers[0]))
     return null;
   const statements = source.statements.filter(
-    (node) => !ts8.isExportDeclaration(node)
+    (node) => !ts11.isExportDeclaration(node)
   );
-  if (statements[0] !== contract || statements[1] !== consumer || statements[2] !== implementation || statements[3] === void 0 || !ts8.isExpressionStatement(statements[3]) || statements[3].expression !== call)
+  if (statements[0] !== contract || statements[1] !== consumer || statements[2] !== implementation || statements[3] === void 0 || !ts11.isExpressionStatement(statements[3]) || statements[3].expression !== call)
     return null;
-  if (!plainClass(contract, ts8.SyntaxKind.AbstractKeyword) || !plainClass(consumer, null) || !plainClass(implementation, null) || contract.name === void 0 || consumer.name === void 0 || implementation.name === void 0 || (/* @__PURE__ */ new Set([contract.name.text, consumer.name.text, implementation.name.text])).size !== 3)
+  if (!plainClass(contract, ts11.SyntaxKind.AbstractKeyword) || !plainClass(consumer, null) || !plainClass(implementation, null) || contract.name === void 0 || consumer.name === void 0 || implementation.name === void 0 || (/* @__PURE__ */ new Set([contract.name.text, consumer.name.text, implementation.name.text])).size !== 3)
     return null;
   const method = emptyContractMethod(contract);
   if (method === null || !emptyImplementation(implementation, method) || !exactConsumer(sourceCode, consumer, contract.name.text) || !exactConstruction(call, consumer.name.text, implementation.name.text))
@@ -1694,47 +2248,47 @@ function closedNominalInheritanceFix(sourceCode, call, consumer, implementation,
   );
 }
 function emptyModuleMarker(node) {
-  return !node.isTypeOnly && node.moduleSpecifier === void 0 && node.attributes === void 0 && node.exportClause !== void 0 && ts8.isNamedExports(node.exportClause) && node.exportClause.elements.length === 0;
+  return !node.isTypeOnly && node.moduleSpecifier === void 0 && node.attributes === void 0 && node.exportClause !== void 0 && ts11.isNamedExports(node.exportClause) && node.exportClause.elements.length === 0;
 }
 function plainClass(node, modifier) {
-  const modifiers = ts8.getModifiers(node) ?? [];
-  return node.name !== void 0 && node.typeParameters === void 0 && node.heritageClauses === void 0 && (ts8.getDecorators(node)?.length ?? 0) === 0 && modifiers.length === (modifier === null ? 0 : 1) && (modifier === null || modifiers[0]?.kind === modifier);
+  const modifiers = ts11.getModifiers(node) ?? [];
+  return node.name !== void 0 && node.typeParameters === void 0 && node.heritageClauses === void 0 && (ts11.getDecorators(node)?.length ?? 0) === 0 && modifiers.length === (modifier === null ? 0 : 1) && (modifier === null || modifiers[0]?.kind === modifier);
 }
 function emptyContractMethod(node) {
   const method = node.members[0];
-  if (node.members.length !== 1 || method === void 0 || !ts8.isMethodDeclaration(method) || !ts8.isIdentifier(method.name) || method.name.text === "constructor" || method.parameters.length !== 0 || method.typeParameters !== void 0 || method.questionToken !== void 0 || method.asteriskToken !== void 0 || method.body !== void 0 || method.type?.kind !== ts8.SyntaxKind.VoidKeyword || method.modifiers?.length !== 1 || method.modifiers[0]?.kind !== ts8.SyntaxKind.AbstractKeyword)
+  if (node.members.length !== 1 || method === void 0 || !ts11.isMethodDeclaration(method) || !ts11.isIdentifier(method.name) || method.name.text === "constructor" || method.parameters.length !== 0 || method.typeParameters !== void 0 || method.questionToken !== void 0 || method.asteriskToken !== void 0 || method.body !== void 0 || method.type?.kind !== ts11.SyntaxKind.VoidKeyword || method.modifiers?.length !== 1 || method.modifiers[0]?.kind !== ts11.SyntaxKind.AbstractKeyword)
     return null;
   return method.name.text;
 }
 function emptyImplementation(node, key) {
   const method = node.members[0];
-  return node.members.length === 1 && method !== void 0 && ts8.isMethodDeclaration(method) && ts8.isIdentifier(method.name) && method.name.text === key && method.parameters.length === 0 && method.typeParameters === void 0 && method.questionToken === void 0 && method.asteriskToken === void 0 && method.modifiers === void 0 && (method.type === void 0 || method.type.kind === ts8.SyntaxKind.VoidKeyword) && method.body?.statements.length === 0;
+  return node.members.length === 1 && method !== void 0 && ts11.isMethodDeclaration(method) && ts11.isIdentifier(method.name) && method.name.text === key && method.parameters.length === 0 && method.typeParameters === void 0 && method.questionToken === void 0 && method.asteriskToken === void 0 && method.modifiers === void 0 && (method.type === void 0 || method.type.kind === ts11.SyntaxKind.VoidKeyword) && method.body?.statements.length === 0;
 }
 function exactConsumer(sourceCode, consumer, base) {
   const constructor = consumer.members[0];
-  if (consumer.members.length !== 1 || constructor === void 0 || !ts8.isConstructorDeclaration(constructor) || constructor.modifiers !== void 0 || constructor.parameters.length !== 1 || constructor.body?.statements.length !== 1)
+  if (consumer.members.length !== 1 || constructor === void 0 || !ts11.isConstructorDeclaration(constructor) || constructor.modifiers !== void 0 || constructor.parameters.length !== 1 || constructor.body?.statements.length !== 1)
     return false;
   const parameter = constructor.parameters[0];
-  if (parameter === void 0 || !ts8.isIdentifier(parameter.name) || parameter.name.text === base || parameter.initializer !== void 0 || parameter.questionToken !== void 0 || parameter.dotDotDotToken !== void 0 || parameter.modifiers?.length !== 1 || parameter.modifiers[0]?.kind !== ts8.SyntaxKind.ReadonlyKeyword || parameter.type === void 0 || !ts8.isTypeReferenceNode(parameter.type) || !ts8.isIdentifier(parameter.type.typeName) || parameter.type.typeName.text !== base || parameter.type.typeArguments !== void 0)
+  if (parameter === void 0 || !ts11.isIdentifier(parameter.name) || parameter.name.text === base || parameter.initializer !== void 0 || parameter.questionToken !== void 0 || parameter.dotDotDotToken !== void 0 || parameter.modifiers?.length !== 1 || parameter.modifiers[0]?.kind !== ts11.SyntaxKind.ReadonlyKeyword || parameter.type === void 0 || !ts11.isTypeReferenceNode(parameter.type) || !ts11.isIdentifier(parameter.type.typeName) || parameter.type.typeName.text !== base || parameter.type.typeArguments !== void 0)
     return false;
   const guard = constructor.body.statements[0];
-  if (guard === void 0 || !ts8.isIfStatement(guard) || guard.elseStatement !== void 0)
+  if (guard === void 0 || !ts11.isIfStatement(guard) || guard.elseStatement !== void 0)
     return false;
   const condition2 = unparenthesized(guard.expression);
-  if (!ts8.isPrefixUnaryExpression(condition2) || condition2.operator !== ts8.SyntaxKind.ExclamationToken)
+  if (!ts11.isPrefixUnaryExpression(condition2) || condition2.operator !== ts11.SyntaxKind.ExclamationToken)
     return false;
   const comparison2 = unparenthesized(condition2.operand);
-  return ts8.isBinaryExpression(comparison2) && comparison2.operatorToken.kind === ts8.SyntaxKind.InstanceOfKeyword && ts8.isIdentifier(comparison2.left) && comparison2.left.text === parameter.name.text && ts8.isIdentifier(comparison2.right) && comparison2.right.text === base && exactRejection(sourceCode, guard.thenStatement);
+  return ts11.isBinaryExpression(comparison2) && comparison2.operatorToken.kind === ts11.SyntaxKind.InstanceOfKeyword && ts11.isIdentifier(comparison2.left) && comparison2.left.text === parameter.name.text && ts11.isIdentifier(comparison2.right) && comparison2.right.text === base && exactRejection(sourceCode, guard.thenStatement);
 }
 function unparenthesized(node) {
   let expression = node;
-  while (ts8.isParenthesizedExpression(expression))
+  while (ts11.isParenthesizedExpression(expression))
     expression = expression.expression;
   return expression;
 }
 function exactRejection(sourceCode, statement) {
-  const rejected = ts8.isBlock(statement) && statement.statements.length === 1 ? statement.statements[0] : statement;
-  if (rejected === void 0 || !ts8.isThrowStatement(rejected) || rejected.expression === void 0 || !ts8.isNewExpression(rejected.expression) || !ts8.isIdentifier(rejected.expression.expression) || rejected.expression.expression.text !== "TypeError" || rejected.expression.typeArguments !== void 0 || rejected.expression.arguments?.length !== 1 || rejected.expression.arguments[0] === void 0 || !ts8.isStringLiteral(rejected.expression.arguments[0]))
+  const rejected = ts11.isBlock(statement) && statement.statements.length === 1 ? statement.statements[0] : statement;
+  if (rejected === void 0 || !ts11.isThrowStatement(rejected) || rejected.expression === void 0 || !ts11.isNewExpression(rejected.expression) || !ts11.isIdentifier(rejected.expression.expression) || rejected.expression.expression.text !== "TypeError" || rejected.expression.typeArguments !== void 0 || rejected.expression.arguments?.length !== 1 || rejected.expression.arguments[0] === void 0 || !ts11.isStringLiteral(rejected.expression.arguments[0]))
     return false;
   const identifier = sourceCode.getNodeByRangeIndex(
     rejected.expression.expression.getStart()
@@ -1742,14 +2296,15 @@ function exactRejection(sourceCode, statement) {
   return identifier?.type === AST_NODE_TYPES13.Identifier && identifier.name === "TypeError" && (ASTUtils4.findVariable(sourceCode.getScope(identifier), identifier.name)?.defs.length ?? 0) === 0;
 }
 function exactConstruction(node, consumer, implementation) {
-  if (!ts8.isIdentifier(node.expression) || node.expression.text !== consumer || node.typeArguments !== void 0 || node.arguments?.length !== 1)
+  if (!ts11.isIdentifier(node.expression) || node.expression.text !== consumer || node.typeArguments !== void 0 || node.arguments?.length !== 1)
     return false;
   const argument = node.arguments[0];
-  return argument !== void 0 && ts8.isNewExpression(argument) && ts8.isIdentifier(argument.expression) && argument.expression.text === implementation && argument.typeArguments === void 0 && argument.arguments?.length === 0;
+  return argument !== void 0 && ts11.isNewExpression(argument) && ts11.isIdentifier(argument.expression) && argument.expression.text === implementation && argument.typeArguments === void 0 && argument.arguments?.length === 0;
 }
 
 // src/rules/require-explicit-contract-implementation.ts
 var ESCAPED_CLASSES = /* @__PURE__ */ new WeakMap();
+var PROTOTYPE_MUTATIONS = /* @__PURE__ */ new WeakMap();
 var REQUIRE_EXPLICIT_CONTRACT_IMPLEMENTATION_DOCUMENTATION = {
   defaultLevel: "error",
   summary: "Require nominal inheritance when an injected abstract class is rejected by an instanceof guard.",
@@ -1814,19 +2369,23 @@ var REQUIRE_EXPLICIT_CONTRACT_IMPLEMENTATION_DOCUMENTATION = {
   ]
 };
 function hasPrototypeMutation(source) {
+  const cached = PROTOTYPE_MUTATIONS.get(source);
+  if (cached !== void 0) return cached;
   function visit(node) {
     const member3 = memberName(node);
     if (member3 === "setPrototypeOf" || member3 === "__proto__" || member3 === "hasInstance")
       return true;
-    if (ts9.isBinaryExpression(node) && node.operatorToken.kind >= ts9.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts9.SyntaxKind.LastAssignment && memberName(node.left) === "prototype")
+    if (ts12.isBinaryExpression(node) && node.operatorToken.kind >= ts12.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts12.SyntaxKind.LastAssignment && memberName(node.left) === "prototype")
       return true;
-    return ts9.forEachChild(node, visit);
+    return ts12.forEachChild(node, visit);
   }
-  return visit(source) === true;
+  const mutated = visit(source) === true;
+  PROTOTYPE_MUTATIONS.set(source, mutated);
+  return mutated;
 }
 function memberName(node) {
-  if (ts9.isPropertyAccessExpression(node)) return node.name.text;
-  if (ts9.isElementAccessExpression(node) && ts9.isStringLiteralLike(node.argumentExpression))
+  if (ts12.isPropertyAccessExpression(node)) return node.name.text;
+  if (ts12.isElementAccessExpression(node) && ts12.isStringLiteralLike(node.argumentExpression))
     return node.argumentExpression.text;
   return null;
 }
@@ -1843,11 +2402,11 @@ function escapedClasses(program, checker, cwd) {
   const escaped = /* @__PURE__ */ new Set();
   const namespaceValues = /* @__PURE__ */ new Map();
   function visit(node) {
-    if (ts9.isTypeNode(node) || ts9.isImportDeclaration(node)) return;
-    if (ts9.isIdentifier(node) || ts9.isPropertyAccessExpression(node) || ts9.isElementAccessExpression(node)) {
+    if (ts12.isTypeNode(node) || ts12.isImportDeclaration(node)) return;
+    if (ts12.isIdentifier(node) || ts12.isPropertyAccessExpression(node) || ts12.isElementAccessExpression(node)) {
       recordEscapedReference(checker, node, escaped, namespaceValues, cwd);
     }
-    ts9.forEachChild(node, visit);
+    ts12.forEachChild(node, visit);
   }
   for (const source of program.getSourceFiles())
     if (ownedSource(source, cwd)) visit(source);
@@ -1866,7 +2425,7 @@ function recordEscapedReference(checker, node, escaped, namespaceValues, cwd) {
     if (!namespacePrefix(symbol, node) && !safeClassReference(node))
       for (const value of values) escaped.add(value);
   }
-  if (ts9.isElementAccessExpression(node) && !safeClassReference(node)) {
+  if (ts12.isElementAccessExpression(node) && !safeClassReference(node)) {
     const receiver = canonicalSymbol(checker, node.expression) ?? checker.getTypeAtLocation(node.expression).getSymbol();
     if (receiver !== void 0)
       for (const value of ownedClassValues(checker, receiver, cwd))
@@ -1874,16 +2433,16 @@ function recordEscapedReference(checker, node, escaped, namespaceValues, cwd) {
   }
 }
 function ownedClassValues(checker, original, cwd, seen = /* @__PURE__ */ new Set()) {
-  const symbol = original.flags & ts9.SymbolFlags.Alias ? checker.getAliasedSymbol(original) : original;
+  const symbol = original.flags & ts12.SymbolFlags.Alias ? checker.getAliasedSymbol(original) : original;
   const values = /* @__PURE__ */ new Set();
   if (seen.has(symbol)) return values;
   seen.add(symbol);
   if (symbol.declarations?.some(
-    (declaration) => ts9.isClassDeclaration(declaration) && ownedSource(declaration.getSourceFile(), cwd)
+    (declaration) => ts12.isClassDeclaration(declaration) && ownedSource(declaration.getSourceFile(), cwd)
   ))
     values.add(symbol);
   if (symbol.declarations?.some(
-    (declaration) => (ts9.isSourceFile(declaration) || ts9.isModuleDeclaration(declaration)) && ownedSource(declaration.getSourceFile(), cwd)
+    (declaration) => (ts12.isSourceFile(declaration) || ts12.isModuleDeclaration(declaration)) && ownedSource(declaration.getSourceFile(), cwd)
   )) {
     for (const exported of checker.getExportsOfModule(symbol)) {
       for (const value of ownedClassValues(checker, exported, cwd, seen))
@@ -1893,16 +2452,16 @@ function ownedClassValues(checker, original, cwd, seen = /* @__PURE__ */ new Set
   return values;
 }
 function safeClassReference(node) {
-  let reference = ts9.isPropertyAccessExpression(node.parent) && node.parent.name === node ? node.parent : node;
-  while (ts9.isParenthesizedExpression(reference.parent))
+  let reference = ts12.isPropertyAccessExpression(node.parent) && node.parent.name === node ? node.parent : node;
+  while (ts12.isParenthesizedExpression(reference.parent))
     reference = reference.parent;
   const parent = reference.parent;
-  return ts9.isClassDeclaration(parent) && parent.name === reference || ts9.isNewExpression(parent) && parent.expression === reference || ts9.isExpressionWithTypeArguments(parent) && parent.expression === reference || ts9.isBinaryExpression(parent) && parent.operatorToken.kind === ts9.SyntaxKind.InstanceOfKeyword && parent.right === reference;
+  return ts12.isClassDeclaration(parent) && parent.name === reference || ts12.isNewExpression(parent) && parent.expression === reference || ts12.isExpressionWithTypeArguments(parent) && parent.expression === reference || ts12.isBinaryExpression(parent) && parent.operatorToken.kind === ts12.SyntaxKind.InstanceOfKeyword && parent.right === reference;
 }
 function namespacePrefix(symbol, node) {
   const parent = node.parent;
-  const memberCall = (ts9.isPropertyAccessExpression(parent) || ts9.isElementAccessExpression(parent)) && ts9.isCallExpression(parent.parent) && parent.parent.expression === parent;
-  return !symbol.declarations?.some(ts9.isClassDeclaration) && (ts9.isPropertyAccessExpression(parent) || ts9.isElementAccessExpression(parent)) && parent.expression === node && !memberCall;
+  const memberCall = (ts12.isPropertyAccessExpression(parent) || ts12.isElementAccessExpression(parent)) && ts12.isCallExpression(parent.parent) && parent.parent.expression === parent;
+  return !symbol.declarations?.some(ts12.isClassDeclaration) && (ts12.isPropertyAccessExpression(parent) || ts12.isElementAccessExpression(parent)) && parent.expression === node && !memberCall;
 }
 function closedNominalBoundary(program, checker, call, consumer, missing, cwd) {
   const { implementation, contractSymbol } = missing;
@@ -1910,7 +2469,7 @@ function closedNominalBoundary(program, checker, call, consumer, missing, cwd) {
   const consumerSymbol = consumer.name === void 0 ? void 0 : canonicalSymbol(checker, consumer.name);
   if (implementationSymbol === void 0 || consumerSymbol === void 0)
     return false;
-  const contract = contractSymbol.declarations?.find(ts9.isClassDeclaration);
+  const contract = contractSymbol.declarations?.find(ts12.isClassDeclaration);
   if (contract === void 0) return false;
   const targets = /* @__PURE__ */ new Set([
     consumerSymbol,
@@ -1932,12 +2491,12 @@ function classHierarchySymbols(checker, declaration, seen = /* @__PURE__ */ new
   if (symbol === void 0 || seen.has(symbol)) return seen;
   seen.add(symbol);
   for (const clause of declaration.heritageClauses ?? []) {
-    if (clause.token !== ts9.SyntaxKind.ExtendsKeyword) continue;
+    if (clause.token !== ts12.SyntaxKind.ExtendsKeyword) continue;
     for (const parent of clause.types) {
       const ancestor = canonicalSymbol(
         checker,
         parent.expression
-      )?.declarations?.find(ts9.isClassDeclaration);
+      )?.declarations?.find(ts12.isClassDeclaration);
       if (ancestor !== void 0)
         classHierarchySymbols(checker, ancestor, seen);
     }
@@ -1962,22 +2521,22 @@ function missingImplementation(checker, signature, parameter, call, argument) {
 function behavioralContract(checker, type) {
   if (type.isUnion()) {
     const substantive = type.types.filter(
-      (member3) => (member3.flags & (ts9.TypeFlags.Null | ts9.TypeFlags.Undefined)) === 0
+      (member3) => (member3.flags & (ts12.TypeFlags.Null | ts12.TypeFlags.Undefined)) === 0
     );
     if (substantive.length !== 1) return null;
     return behavioralContract(checker, substantive[0]);
   }
-  if ((type.flags & (ts9.TypeFlags.Any | ts9.TypeFlags.Unknown)) !== 0)
+  if ((type.flags & (ts12.TypeFlags.Any | ts12.TypeFlags.Unknown)) !== 0)
     return null;
   const declaration = type.getSymbol()?.declarations?.find(
-    (item) => ts9.isClassDeclaration(item) && item.modifiers?.some(
-      (modifier) => modifier.kind === ts9.SyntaxKind.AbstractKeyword
+    (item) => ts12.isClassDeclaration(item) && item.modifiers?.some(
+      (modifier) => modifier.kind === ts12.SyntaxKind.AbstractKeyword
     )
   );
   if (declaration === void 0) return null;
   return checker.getPropertiesOfType(type).some((property) => {
     if (!property.declarations?.some(
-      (member3) => ts9.isMethodSignature(member3) || ts9.isMethodDeclaration(member3)
+      (member3) => ts12.isMethodSignature(member3) || ts12.isMethodDeclaration(member3)
     ))
       return false;
     const propertyType = checker.getTypeOfSymbolAtLocation(
@@ -1988,15 +2547,15 @@ function behavioralContract(checker, type) {
   }) ? type : null;
 }
 function ownedClass(checker, expression) {
-  if (!ts9.isNewExpression(expression)) return null;
+  if (!ts12.isNewExpression(expression)) return null;
   const type = checker.getTypeAtLocation(expression);
-  if ((type.flags & (ts9.TypeFlags.Any | ts9.TypeFlags.Unknown)) !== 0)
+  if ((type.flags & (ts12.TypeFlags.Any | ts12.TypeFlags.Unknown)) !== 0)
     return null;
-  const declaration = type.getSymbol()?.declarations?.find(ts9.isClassDeclaration);
+  const declaration = type.getSymbol()?.declarations?.find(ts12.isClassDeclaration);
   const constructed = canonicalSymbol(
     checker,
     expression.expression
-  )?.declarations?.find(ts9.isClassDeclaration);
+  )?.declarations?.find(ts12.isClassDeclaration);
   if (declaration === void 0 || declaration !== constructed || declaration.getSourceFile().isDeclarationFile || /(?:^|[/\\])(?:node_modules|vendor|generated)(?:[/\\])/u.test(
     declaration.getSourceFile().fileName
   ))
@@ -2004,10 +2563,10 @@ function ownedClass(checker, expression) {
   return declaration;
 }
 function nominallyInherits(checker, declaration, target, seen) {
-  if (ts9.canHaveDecorators(declaration) && ts9.getDecorators(declaration)?.length)
+  if (ts12.canHaveDecorators(declaration) && ts12.getDecorators(declaration)?.length)
     return null;
   if (hasPrototypeMutation(declaration.getSourceFile()) || declaration.members.some(
-    (member3) => ts9.isConstructorDeclaration(member3) || ts9.isClassStaticBlockDeclaration(member3) || ts9.isPropertyDeclaration(member3) && member3.initializer !== void 0
+    (member3) => ts12.isConstructorDeclaration(member3) || ts12.isClassStaticBlockDeclaration(member3) || ts12.isPropertyDeclaration(member3) && member3.initializer !== void 0
   ))
     return null;
   const symbol = declaration.name === void 0 ? void 0 : canonicalSymbol(checker, declaration.name);
@@ -2016,60 +2575,60 @@ function nominallyInherits(checker, declaration, target, seen) {
     seen.add(symbol);
   }
   const parents = declaration.heritageClauses?.find(
-    (clause) => clause.token === ts9.SyntaxKind.ExtendsKeyword
+    (clause) => clause.token === ts12.SyntaxKind.ExtendsKeyword
   )?.types;
   if (parents === void 0) return false;
   if (parents.length !== 1) return null;
   const parentSymbol = canonicalSymbol(checker, parents[0].expression);
   if (parentSymbol === void 0) return null;
   if (parentSymbol === target) return true;
-  const inherited = parentSymbol.declarations?.find(ts9.isClassDeclaration);
+  const inherited = parentSymbol.declarations?.find(ts12.isClassDeclaration);
   return inherited === void 0 ? null : nominallyInherits(checker, inherited, target, new Set(seen));
 }
 function hasNominalRejectionGuard(checker, signature, parameter, contract) {
   const declaration = signature.getDeclaration();
-  if (declaration === void 0 || !ts9.isConstructorDeclaration(declaration))
+  if (declaration === void 0 || !ts12.isConstructorDeclaration(declaration))
     return false;
-  if (ts9.canHaveDecorators(declaration.parent) && ts9.getDecorators(declaration.parent)?.length)
+  if (ts12.canHaveDecorators(declaration.parent) && ts12.getDecorators(declaration.parent)?.length)
     return false;
   if (hasPrototypeMutation(declaration.getSourceFile())) return false;
   const first = declaration.body?.statements[0];
-  if (first === void 0 || !ts9.isIfStatement(first) || !alwaysThrows(first.thenStatement))
+  if (first === void 0 || !ts12.isIfStatement(first) || !alwaysThrows(first.thenStatement))
     return false;
   const condition2 = unparenthesized2(first.expression);
-  if (!ts9.isPrefixUnaryExpression(condition2) || condition2.operator !== ts9.SyntaxKind.ExclamationToken)
+  if (!ts12.isPrefixUnaryExpression(condition2) || condition2.operator !== ts12.SyntaxKind.ExclamationToken)
     return false;
   const comparison2 = unparenthesized2(condition2.operand);
-  if (!ts9.isBinaryExpression(comparison2) || comparison2.operatorToken.kind !== ts9.SyntaxKind.InstanceOfKeyword)
+  if (!ts12.isBinaryExpression(comparison2) || comparison2.operatorToken.kind !== ts12.SyntaxKind.InstanceOfKeyword)
     return false;
   if (canonicalSymbol(checker, comparison2.left) !== parameter || canonicalSymbol(checker, comparison2.right) !== contract)
     return false;
-  const target = contract.declarations?.find(ts9.isClassDeclaration);
+  const target = contract.declarations?.find(ts12.isClassDeclaration);
   return target !== void 0 && hasOrdinaryInstanceCheck(checker, target, /* @__PURE__ */ new Set());
 }
 function unparenthesized2(expression) {
   let current = expression;
-  while (ts9.isParenthesizedExpression(current)) current = current.expression;
+  while (ts12.isParenthesizedExpression(current)) current = current.expression;
   return current;
 }
 function alwaysThrows(statement) {
-  return ts9.isThrowStatement(statement) || ts9.isBlock(statement) && statement.statements.length === 1 && ts9.isThrowStatement(statement.statements[0]);
+  return ts12.isThrowStatement(statement) || ts12.isBlock(statement) && statement.statements.length === 1 && ts12.isThrowStatement(statement.statements[0]);
 }
 function hasOrdinaryInstanceCheck(checker, declaration, seen) {
-  if (seen.has(declaration) || ts9.getDecorators(declaration)?.length || hasPrototypeMutation(declaration.getSourceFile()) || declaration.members.some(ts9.isClassStaticBlockDeclaration))
+  if (seen.has(declaration) || ts12.getDecorators(declaration)?.length || hasPrototypeMutation(declaration.getSourceFile()) || declaration.members.some(ts12.isClassStaticBlockDeclaration))
     return false;
   seen.add(declaration);
   if (declaration.members.some(
-    (member3) => member3.name !== void 0 && ts9.isComputedPropertyName(member3.name) && ts9.canHaveModifiers(member3) && ts9.getModifiers(member3)?.some((modifier) => modifier.kind === ts9.SyntaxKind.StaticKeyword)
+    (member3) => member3.name !== void 0 && ts12.isComputedPropertyName(member3.name) && ts12.canHaveModifiers(member3) && ts12.getModifiers(member3)?.some((modifier) => modifier.kind === ts12.SyntaxKind.StaticKeyword)
   ))
     return false;
   for (const clause of declaration.heritageClauses ?? []) {
-    if (clause.token !== ts9.SyntaxKind.ExtendsKeyword) continue;
+    if (clause.token !== ts12.SyntaxKind.ExtendsKeyword) continue;
     for (const parent of clause.types) {
       const ancestor = canonicalSymbol(
         checker,
         parent.expression
-      )?.declarations?.find(ts9.isClassDeclaration);
+      )?.declarations?.find(ts12.isClassDeclaration);
       if (ancestor === void 0 || !hasOrdinaryInstanceCheck(checker, ancestor, seen))
         return false;
     }
@@ -2077,9 +2636,9 @@ function hasOrdinaryInstanceCheck(checker, declaration, seen) {
   return true;
 }
 function canonicalSymbol(checker, node) {
-  if (ts9.isParenthesizedExpression(node)) node = unparenthesized2(node);
+  if (ts12.isParenthesizedExpression(node)) node = unparenthesized2(node);
   const symbol = checker.getSymbolAtLocation(node);
-  return symbol === void 0 ? void 0 : (symbol.flags & ts9.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
+  return symbol === void 0 ? void 0 : (symbol.flags & ts12.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
 }
 var require_explicit_contract_implementation_default = createRule({
   name: "require-explicit-contract-implementation",
@@ -2104,11 +2663,11 @@ var require_explicit_contract_implementation_default = createRule({
     const checker = services.program.getTypeChecker();
     function inspect(node) {
       const tsNode = services.esTreeNodeToTSNodeMap.get(node);
-      if (!ts9.isNewExpression(tsNode)) return;
+      if (!ts12.isNewExpression(tsNode)) return;
       const consumer = canonicalSymbol(
         checker,
         tsNode.expression
-      )?.declarations?.find(ts9.isClassDeclaration);
+      )?.declarations?.find(ts12.isClassDeclaration);
       if (consumer === void 0) return;
       const signature = checker.getResolvedSignature(tsNode);
       if (signature === void 0 || signature.getDeclaration()?.parent !== consumer)
@@ -2136,7 +2695,7 @@ var require_explicit_contract_implementation_default = createRule({
         ))
           continue;
         const contract = missing.contractSymbol.declarations?.find(
-          ts9.isClassDeclaration
+          ts12.isClassDeclaration
         );
         context.report({
           node: argument,
@@ -3437,7 +3996,7 @@ import {
   ASTUtils as ASTUtils7,
   ESLintUtils as ESLintUtils7
 } from "@typescript-eslint/utils";
-import ts10 from "typescript";
+import ts13 from "typescript";
 var PREFER_TYPED_REFLECTION_DOCUMENTATION = {
   summary: "Prefer typed access when Reflect.get or Reflect.apply discards a known contract.",
   rationale: "Reflect.get and Reflect.apply can accept property or argument mistakes that normal typed access catches.",
@@ -3490,7 +4049,7 @@ var PREFER_TYPED_REFLECTION_DOCUMENTATION = {
 };
 function knownType(type) {
   if (type.isUnion()) return type.types.every(knownType);
-  return (type.flags & (ts10.TypeFlags.Any | ts10.TypeFlags.Unknown | ts10.TypeFlags.TypeParameter | ts10.TypeFlags.Never)) === 0;
+  return (type.flags & (ts13.TypeFlags.Any | ts13.TypeFlags.Unknown | ts13.TypeFlags.TypeParameter | ts13.TypeFlags.Never)) === 0;
 }
 var prefer_typed_reflection_default = createRule({
   name: "prefer-typed-reflection",
@@ -3542,7 +4101,7 @@ var prefer_typed_reflection_default = createRule({
       const key = unwrapExpression(writtenKey);
       const name = staticString(key) ?? (key.type === AST_NODE_TYPES18.Literal && typeof key.value === "number" ? String(key.value) : null);
       const members = type.isUnion() ? type.types : [type];
-      if (name === null || !members.every((member3) => (member3.flags & ts10.TypeFlags.Object) !== 0 && checker.getPropertyOfType(member3, name) !== void 0)) return null;
+      if (name === null || !members.every((member3) => (member3.flags & ts13.TypeFlags.Object) !== 0 && checker.getPropertyOfType(member3, name) !== void 0)) return null;
       return `(${context.sourceCode.getText(target)})[${context.sourceCode.getText(writtenKey)}]`;
     };
     return {
@@ -3570,7 +4129,7 @@ import {
   AST_NODE_TYPES as AST_NODE_TYPES20,
   ESLintUtils as ESLintUtils8
 } from "@typescript-eslint/utils";
-import ts11 from "typescript";
+import ts14 from "typescript";
 
 // src/rules/_unused-private-binding.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES19 } from "@typescript-eslint/utils";
@@ -3671,21 +4230,21 @@ var NO_BROAD_RETURN_TYPE_DOCUMENTATION = {
   ]
 };
 function isBroad(type, checker) {
-  if ((type.flags & (ts11.TypeFlags.Unknown | ts11.TypeFlags.NonPrimitive)) !== 0)
+  if ((type.flags & (ts14.TypeFlags.Unknown | ts14.TypeFlags.NonPrimitive)) !== 0)
     return true;
   const indexes = checker.getIndexInfosOfType(type);
-  return indexes.length > 0 && type.getProperties().length === 0 && indexes.every((index) => (index.type.flags & ts11.TypeFlags.Unknown) !== 0);
+  return indexes.length > 0 && type.getProperties().length === 0 && indexes.every((index) => (index.type.flags & ts14.TypeFlags.Unknown) !== 0);
 }
 function hasKnownContract(type, checker) {
   if (type.isUnion())
     return type.types.every((part) => hasKnownContract(part, checker));
-  const excluded = ts11.TypeFlags.Any | ts11.TypeFlags.Unknown | ts11.TypeFlags.Never | ts11.TypeFlags.TypeParameter | ts11.TypeFlags.Conditional | ts11.TypeFlags.IndexedAccess | ts11.TypeFlags.Substitution | ts11.TypeFlags.Null | ts11.TypeFlags.Undefined | ts11.TypeFlags.Void;
+  const excluded = ts14.TypeFlags.Any | ts14.TypeFlags.Unknown | ts14.TypeFlags.Never | ts14.TypeFlags.TypeParameter | ts14.TypeFlags.Conditional | ts14.TypeFlags.IndexedAccess | ts14.TypeFlags.Substitution | ts14.TypeFlags.Null | ts14.TypeFlags.Undefined | ts14.TypeFlags.Void;
   if ((type.flags & excluded) !== 0 || isBroad(type, checker)) return false;
-  return (type.flags & ts11.TypeFlags.Object) === 0 || type.getProperties().length > 0;
+  return (type.flags & ts14.TypeFlags.Object) === 0 || type.getProperties().length > 0;
 }
 function isOpaque(type, checker) {
   if (type.isUnion()) return type.types.some((part) => isOpaque(part, checker));
-  return (type.flags & (ts11.TypeFlags.Any | ts11.TypeFlags.Unknown | ts11.TypeFlags.TypeParameter | ts11.TypeFlags.Conditional | ts11.TypeFlags.IndexedAccess | ts11.TypeFlags.Substitution)) !== 0 || isBroad(type, checker);
+  return (type.flags & (ts14.TypeFlags.Any | ts14.TypeFlags.Unknown | ts14.TypeFlags.TypeParameter | ts14.TypeFlags.Conditional | ts14.TypeFlags.IndexedAccess | ts14.TypeFlags.Substitution)) !== 0 || isBroad(type, checker);
 }
 var no_broad_return_type_default = createRule({
   name: "no-broad-return-type",
@@ -3712,7 +4271,7 @@ var no_broad_return_type_default = createRule({
       const type = checker.getTypeAtLocation(
         services.esTreeNodeToTSNodeMap.get(node)
       );
-      return (type.flags & ts11.TypeFlags.TypeParameter) !== 0 ? type : checker.getAwaitedType(type) ?? type;
+      return (type.flags & ts14.TypeFlags.TypeParameter) !== 0 ? type : checker.getAwaitedType(type) ?? type;
     };
     const inspectReturn = (value) => {
       const frame = frames.at(-1);
@@ -3761,7 +4320,7 @@ import {
   ASTUtils as ASTUtils9,
   ESLintUtils as ESLintUtils9
 } from "@typescript-eslint/utils";
-import ts12 from "typescript";
+import ts15 from "typescript";
 
 // src/rules/_literal-identity-reduce-fix.ts
 import {
@@ -3924,7 +4483,7 @@ var no_reduce_accumulator_copy_default = createRule({
           services.esTreeNodeToTSNodeMap.get(node)
         );
         const declaration = signature?.declaration;
-        if (!declaration || !program.isSourceFileDefaultLibrary(declaration.getSourceFile()) || !ts12.isInterfaceDeclaration(declaration.parent) || !["Array", "ReadonlyArray"].includes(declaration.parent.name.text))
+        if (!declaration || !program.isSourceFileDefaultLibrary(declaration.getSourceFile()) || !ts15.isInterfaceDeclaration(declaration.parent) || !["Array", "ReadonlyArray"].includes(declaration.parent.name.text))
           return;
         const accumulator = context.sourceCode.getDeclaredVariables(callback).find((variable) => variable.identifiers.includes(parameter));
         if (!accumulator || accumulator.references.some((reference) => reference.isWrite()))
@@ -3986,7 +4545,7 @@ var no_reduce_accumulator_copy_default = createRule({
 
 // src/rules/no-known-value-widening.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES23, ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
-import ts13 from "typescript";
+import ts16 from "typescript";
 var NO_KNOWN_VALUE_WIDENING_DOCUMENTATION = {
   summary: "Preserve a known value's contract instead of widening a local binding to unknown, object, or an unknown-valued dictionary.",
   rationale: "Erasing a typed value's fields forces downstream code to rediscover the same contract through casts, reflection, or representation checks.",
@@ -4013,13 +4572,13 @@ var NO_KNOWN_VALUE_WIDENING_DOCUMENTATION = {
   ]
 };
 function erasesContract(type, checker) {
-  if ((type.flags & (ts13.TypeFlags.Unknown | ts13.TypeFlags.NonPrimitive)) !== 0) return true;
+  if ((type.flags & (ts16.TypeFlags.Unknown | ts16.TypeFlags.NonPrimitive)) !== 0) return true;
   const indexes = checker.getIndexInfosOfType(type);
-  return indexes.length > 0 && checker.getPropertiesOfType(type).length === 0 && indexes.every((index) => (index.type.flags & ts13.TypeFlags.Unknown) !== 0);
+  return indexes.length > 0 && checker.getPropertiesOfType(type).length === 0 && indexes.every((index) => (index.type.flags & ts16.TypeFlags.Unknown) !== 0);
 }
 function hasUnknownContract(type, checker) {
   if (type.isUnionOrIntersection()) return type.types.some((part) => hasUnknownContract(part, checker));
-  return (type.flags & (ts13.TypeFlags.Any | ts13.TypeFlags.Unknown | ts13.TypeFlags.Never | ts13.TypeFlags.TypeParameter | ts13.TypeFlags.Conditional | ts13.TypeFlags.IndexedAccess | ts13.TypeFlags.Substitution)) !== 0 || erasesContract(type, checker);
+  return (type.flags & (ts16.TypeFlags.Any | ts16.TypeFlags.Unknown | ts16.TypeFlags.Never | ts16.TypeFlags.TypeParameter | ts16.TypeFlags.Conditional | ts16.TypeFlags.IndexedAccess | ts16.TypeFlags.Substitution)) !== 0 || erasesContract(type, checker);
 }
 var no_known_value_widening_default = createRule({
   name: "no-known-value-widening",
@@ -4061,7 +4620,7 @@ var no_known_value_widening_default = createRule({
 // src/rules/no-invalid-typed-mutation.ts
 import { ASTUtils as ASTUtils10, AST_NODE_TYPES as AST_NODE_TYPES24, ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
 import { isObjectType, isTypeReference } from "ts-api-utils";
-import ts14 from "typescript";
+import ts17 from "typescript";
 var NO_INVALID_TYPED_MUTATION_DOCUMENTATION = {
   summary: "Keep native object mutation APIs from writing incompatible values into declared property types.",
   rationale: "Object.assign, Reflect.set and property descriptors accept values that a normal typed property assignment rejects. They can invalidate a domain object's contract while subsequent reads retain its original type.",
@@ -4219,21 +4778,21 @@ function keepsMutableDescriptor(call, method) {
 function declaredTargetType(node, checker) {
   const symbol = checker.getSymbolAtLocation(node);
   const declaration = symbol?.valueDeclaration;
-  if (declaration === void 0 || !(ts14.isVariableDeclaration(declaration) || ts14.isParameter(declaration)) || declaration.type === void 0) return void 0;
+  if (declaration === void 0 || !(ts17.isVariableDeclaration(declaration) || ts17.isParameter(declaration)) || declaration.type === void 0) return void 0;
   const type = checker.getTypeFromTypeNode(declaration.type);
-  if (!definiteType(type, checker) || type.isUnionOrIntersection() || (type.flags & ts14.TypeFlags.Object) === 0 || checker.getIndexInfosOfType(type).length > 0 || type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) return void 0;
+  if (!definiteType(type, checker) || type.isUnionOrIntersection() || (type.flags & ts17.TypeFlags.Object) === 0 || checker.getIndexInfosOfType(type).length > 0 || type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) return void 0;
   return type;
 }
 function typedDataProperty(property) {
   const declarations = property.getDeclarations();
-  return declarations !== void 0 && declarations.length === 1 && declarations.every((declaration) => (ts14.isPropertySignature(declaration) || ts14.isPropertyDeclaration(declaration)) && declaration.type !== void 0);
+  return declarations !== void 0 && declarations.length === 1 && declarations.every((declaration) => (ts17.isPropertySignature(declaration) || ts17.isPropertyDeclaration(declaration)) && declaration.type !== void 0);
 }
 function propertyWriteType(target, property, node, checker, exact) {
   const exposed = checker.getTypeOfSymbolAtLocation(property, node);
-  if (!exact || (property.flags & ts14.SymbolFlags.Optional) === 0 || (property.flags & ts14.SymbolFlags.Transient) !== 0) return exposed;
-  if ((target.aliasTypeArguments?.length ?? 0) > 0 || isTypeReference(target) && checker.getTypeArguments(target).length > 0 || isObjectType(target) && (target.objectFlags & (ts14.ObjectFlags.Mapped | ts14.ObjectFlags.Instantiated)) !== 0) return exposed;
+  if (!exact || (property.flags & ts17.SymbolFlags.Optional) === 0 || (property.flags & ts17.SymbolFlags.Transient) !== 0) return exposed;
+  if ((target.aliasTypeArguments?.length ?? 0) > 0 || isTypeReference(target) && checker.getTypeArguments(target).length > 0 || isObjectType(target) && (target.objectFlags & (ts17.ObjectFlags.Mapped | ts17.ObjectFlags.Instantiated)) !== 0) return exposed;
   const declaration = property.getDeclarations()?.[0];
-  if (declaration === void 0 || !(ts14.isPropertySignature(declaration) || ts14.isPropertyDeclaration(declaration)) || declaration.questionToken === void 0 || declaration.type === void 0) return exposed;
+  if (declaration === void 0 || !(ts17.isPropertySignature(declaration) || ts17.isPropertyDeclaration(declaration)) || declaration.questionToken === void 0 || declaration.type === void 0) return exposed;
   const authored = checker.getTypeFromTypeNode(declaration.type);
   return definiteType(authored, checker) && checker.isTypeAssignableTo(authored, exposed) ? authored : exposed;
 }
@@ -4241,13 +4800,13 @@ function definiteType(type, checker, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(type)) return true;
   if (seen.size >= 32) return false;
   seen.add(type);
-  const unsafe = ts14.TypeFlags.Any | ts14.TypeFlags.Unknown | ts14.TypeFlags.Never | ts14.TypeFlags.TypeParameter | ts14.TypeFlags.Conditional | ts14.TypeFlags.IndexedAccess | ts14.TypeFlags.Substitution;
+  const unsafe = ts17.TypeFlags.Any | ts17.TypeFlags.Unknown | ts17.TypeFlags.Never | ts17.TypeFlags.TypeParameter | ts17.TypeFlags.Conditional | ts17.TypeFlags.IndexedAccess | ts17.TypeFlags.Substitution;
   if ((type.flags & unsafe) !== 0) return false;
   if (type.isUnionOrIntersection()) return type.types.every((part) => definiteType(part, checker, seen));
   const arguments_ = isTypeReference(type) ? checker.getTypeArguments(type) : type.aliasTypeArguments ?? [];
   if (!arguments_.every((argument) => definiteType(argument, checker, seen))) return false;
   if (!definiteSignatures(type, checker, seen)) return false;
-  if (isTypeReference(type) || (type.flags & ts14.TypeFlags.Object) === 0) return true;
+  if (isTypeReference(type) || (type.flags & ts17.TypeFlags.Object) === 0) return true;
   return type.getProperties().every((property) => {
     const declaration = property.valueDeclaration ?? property.getDeclarations()?.[0];
     return declaration !== void 0 && definiteType(checker.getTypeOfSymbolAtLocation(property, declaration), checker, seen);
@@ -4331,33 +4890,33 @@ function plainProperties(node) {
 
 // src/rules/no-contradictory-type-predicate.ts
 import { ASTUtils as ASTUtils12, AST_NODE_TYPES as AST_NODE_TYPES26, ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
-import ts17 from "typescript";
+import ts20 from "typescript";
 
 // src/rules/_has-separate-predicate-contract.ts
-import ts15 from "typescript";
+import ts18 from "typescript";
 function hasSeparatePredicateContract(node, checker) {
-  if (ts15.isFunctionExpression(node) || ts15.isArrowFunction(node)) return checker.getContextualType(node) !== void 0;
-  if (!ts15.isFunctionDeclaration(node) && !ts15.isMethodDeclaration(node)) return true;
+  if (ts18.isFunctionExpression(node) || ts18.isArrowFunction(node)) return checker.getContextualType(node) !== void 0;
+  if (!ts18.isFunctionDeclaration(node) && !ts18.isMethodDeclaration(node)) return true;
   if (node.name !== void 0 && (checker.getSymbolAtLocation(node.name)?.getDeclarations()?.length ?? 0) > 1) return true;
-  if (!ts15.isMethodDeclaration(node)) return false;
+  if (!ts18.isMethodDeclaration(node)) return false;
   const owner = node.parent;
-  if (ts15.isObjectLiteralExpression(owner)) return checker.getContextualType(owner) !== void 0;
-  return (ts15.isClassDeclaration(owner) || ts15.isClassExpression(owner)) && (owner.heritageClauses?.length ?? 0) > 0;
+  if (ts18.isObjectLiteralExpression(owner)) return checker.getContextualType(owner) !== void 0;
+  return (ts18.isClassDeclaration(owner) || ts18.isClassExpression(owner)) && (owner.heritageClauses?.length ?? 0) > 0;
 }
 
 // src/rules/_contradictory-array-predicate.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES25, ASTUtils as ASTUtils11 } from "@typescript-eslint/utils";
-import ts16 from "typescript";
+import ts19 from "typescript";
 import { isTypeReference as isTypeReference2 } from "ts-api-utils";
 var HOST_GLOBALS = ["globalThis", "window", "self", "global"];
-var PRIMITIVE_ELEMENTS = ts16.TypeFlags.String | ts16.TypeFlags.Number | ts16.TypeFlags.Boolean | ts16.TypeFlags.BigInt | ts16.TypeFlags.ESSymbol;
-var OBJECT_REFLECTION = /* @__PURE__ */ new Set(["getPrototypeOf", "getOwnPropertyDescriptor", "getOwnPropertyDescriptors", "prototype", "constructor", "__proto__"]);
+var PRIMITIVE_ELEMENTS = ts19.TypeFlags.String | ts19.TypeFlags.Number | ts19.TypeFlags.Boolean | ts19.TypeFlags.BigInt | ts19.TypeFlags.ESSymbol;
+var OBJECT_REFLECTION2 = /* @__PURE__ */ new Set(["getPrototypeOf", "getOwnPropertyDescriptor", "getOwnPropertyDescriptors", "prototype", "constructor", "__proto__"]);
 function contradictoryArrayPredicate(sourceCode, services) {
   const checker = services.program.getTypeChecker();
   const stable2 = /* @__PURE__ */ new WeakMap();
   let constructorCapability = false;
   function matches(expression, parameter, input, target) {
-    if ((input.flags & ts16.TypeFlags.Unknown) === 0 || !plainPrimitiveArray(target, checker)) return false;
+    if ((input.flags & ts19.TypeFlags.Unknown) === 0 || !plainPrimitiveArray(target, checker)) return false;
     const call = unwrapExpression(expression);
     if (call.type !== AST_NODE_TYPES25.CallExpression || call.optional || call.arguments.length !== 1) return false;
     const argument = call.arguments[0];
@@ -4385,7 +4944,7 @@ function contradictoryArrayPredicate(sourceCode, services) {
 function plainPrimitiveArray(target, checker) {
   if (!checker.isArrayType(target) || !isTypeReference2(target)) return false;
   const [element] = checker.getTypeArguments(target);
-  return element !== void 0 && (element.flags & PRIMITIVE_ELEMENTS) !== 0 && (element.flags & (ts16.TypeFlags.Enum | ts16.TypeFlags.EnumLiteral | ts16.TypeFlags.Intersection)) === 0;
+  return element !== void 0 && (element.flags & PRIMITIVE_ELEMENTS) !== 0 && (element.flags & (ts19.TypeFlags.Enum | ts19.TypeFlags.EnumLiteral | ts19.TypeFlags.Intersection)) === 0;
 }
 function nativeBinding(identifier, sourceCode) {
   const binding3 = ASTUtils11.findVariable(sourceCode.getScope(identifier), identifier.name);
@@ -4417,7 +4976,7 @@ function ordinaryObjectUse(node) {
   const member3 = node.parent;
   if (member3?.type !== AST_NODE_TYPES25.MemberExpression || member3.object !== node) return false;
   const name = ASTUtils11.getPropertyName(member3);
-  return name !== null && !OBJECT_REFLECTION.has(name);
+  return name !== null && !OBJECT_REFLECTION2.has(name);
 }
 function ordinaryArrayReference(reference) {
   if (reference.isWrite()) return false;
@@ -4450,11 +5009,11 @@ function ordinaryHostReference(reference) {
 // src/rules/no-contradictory-type-predicate.ts
 var RUNTIME_KINDS = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined", "object", "function"]);
 var PRIMITIVE_KINDS = [
-  [ts17.TypeFlags.String, "string"],
-  [ts17.TypeFlags.Number, "number"],
-  [ts17.TypeFlags.BigInt, "bigint"],
-  [ts17.TypeFlags.ESSymbol, "symbol"],
-  [ts17.TypeFlags.Undefined, "undefined"]
+  [ts20.TypeFlags.String, "string"],
+  [ts20.TypeFlags.Number, "number"],
+  [ts20.TypeFlags.BigInt, "bigint"],
+  [ts20.TypeFlags.ESSymbol, "symbol"],
+  [ts20.TypeFlags.Undefined, "undefined"]
 ];
 var NO_CONTRADICTORY_TYPE_PREDICATE_DOCUMENTATION = {
   summary: "Keep explicit type predicates consistent with their primitive or native array membership check.",
@@ -4555,10 +5114,10 @@ var no_contradictory_type_predicate_default = createRule({
   }
 });
 function contradiction(input, target, checked, checker, strictNulls) {
-  if (strictNulls && checked === "object" && (target.flags & ts17.TypeFlags.NonPrimitive) !== 0 && admitsNull(input)) return "nullAccepted";
+  if (strictNulls && checked === "object" && (target.flags & ts20.TypeFlags.NonPrimitive) !== 0 && admitsNull(input)) return "nullAccepted";
   const possible = inputKinds(input, checker);
   if (possible === void 0 || !possible.has(checked)) return void 0;
-  if ((target.flags & ts17.TypeFlags.Never) !== 0) return "contradictoryPredicate";
+  if ((target.flags & ts20.TypeFlags.Never) !== 0) return "contradictoryPredicate";
   const promised = primitiveKinds(target, checker, false);
   if (promised !== void 0) {
     return !promised.has(checked) || [...promised].some((kind) => kind !== checked && possible.has(kind)) ? "contradictoryPredicate" : void 0;
@@ -4566,18 +5125,18 @@ function contradiction(input, target, checked, checker, strictNulls) {
   return closedLiteralContradiction(input, target, checked, checker) ? "closedLiteralPredicate" : void 0;
 }
 function admitsNull(input) {
-  return (input.flags & ts17.TypeFlags.Unknown) !== 0 || (input.isUnion() ? input.types : [input]).some((member3) => (member3.flags & ts17.TypeFlags.Null) !== 0);
+  return (input.flags & ts20.TypeFlags.Unknown) !== 0 || (input.isUnion() ? input.types : [input]).some((member3) => (member3.flags & ts20.TypeFlags.Null) !== 0);
 }
 function closedLiteralContradiction(input, target, checked, checker) {
   const members = target.isUnion() ? target.types : [target];
-  const literalFlags = ts17.TypeFlags.StringLiteral | ts17.TypeFlags.NumberLiteral | ts17.TypeFlags.BigIntLiteral | ts17.TypeFlags.BooleanLiteral | ts17.TypeFlags.Null | ts17.TypeFlags.Undefined;
+  const literalFlags = ts20.TypeFlags.StringLiteral | ts20.TypeFlags.NumberLiteral | ts20.TypeFlags.BigIntLiteral | ts20.TypeFlags.BooleanLiteral | ts20.TypeFlags.Null | ts20.TypeFlags.Undefined;
   if (!members.every((member3) => (member3.flags & literalFlags) !== 0)) return false;
   if (members.some((member3) => literalKind(member3, checker) !== checked)) return true;
-  if ((input.flags & ts17.TypeFlags.Unknown) !== 0) return checked !== "undefined";
+  if ((input.flags & ts20.TypeFlags.Unknown) !== 0) return checked !== "undefined";
   return (input.isUnion() ? input.types : [input]).some((member3) => literalKind(member3, checker) === checked && !checker.isTypeAssignableTo(member3, target));
 }
 function literalKind(type, checker) {
-  if ((type.flags & ts17.TypeFlags.BooleanLiteral) !== 0) return "boolean";
+  if ((type.flags & ts20.TypeFlags.BooleanLiteral) !== 0) return "boolean";
   return primitiveKinds(type, checker, true)?.values().next().value;
 }
 function singleReturn(node) {
@@ -4605,7 +5164,7 @@ function sameParameter(declared, tested, sourceCode) {
   return parameter !== null && parameter === ASTUtils12.findVariable(sourceCode.getScope(tested), tested.name);
 }
 function inputKinds(type, checker) {
-  if ((type.flags & ts17.TypeFlags.Unknown) !== 0) return /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined", "object", "function"]);
+  if ((type.flags & ts20.TypeFlags.Unknown) !== 0) return /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined", "object", "function"]);
   return primitiveKinds(type, checker, true);
 }
 function primitiveKinds(type, checker, allowLiterals) {
@@ -4617,7 +5176,7 @@ function primitiveKinds(type, checker, allowLiterals) {
       kinds.add(kind);
       continue;
     }
-    if ((member3.flags & ts17.TypeFlags.BooleanLiteral) === 0) return void 0;
+    if ((member3.flags & ts20.TypeFlags.BooleanLiteral) === 0) return void 0;
     booleans.add(checker.typeToString(member3));
   }
   if (booleans.size > 0) {
@@ -4631,21 +5190,21 @@ function primitiveKind(type, allowLiterals) {
     if ((type.flags & flag) !== 0) return kind;
   }
   if (!allowLiterals) return void 0;
-  if ((type.flags & ts17.TypeFlags.StringLiteral) !== 0) return "string";
-  if ((type.flags & ts17.TypeFlags.NumberLiteral) !== 0) return "number";
-  if ((type.flags & ts17.TypeFlags.BigIntLiteral) !== 0) return "bigint";
-  if ((type.flags & ts17.TypeFlags.Null) !== 0) return "object";
+  if ((type.flags & ts20.TypeFlags.StringLiteral) !== 0) return "string";
+  if ((type.flags & ts20.TypeFlags.NumberLiteral) !== 0) return "number";
+  if ((type.flags & ts20.TypeFlags.BigIntLiteral) !== 0) return "bigint";
+  if ((type.flags & ts20.TypeFlags.Null) !== 0) return "object";
   return void 0;
 }
 
 // src/rules/no-partial-type-predicate.ts
 import { ASTUtils as ASTUtils15, AST_NODE_TYPES as AST_NODE_TYPES29, ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
 import { isNumberLiteralType } from "ts-api-utils";
-import ts19 from "typescript";
+import ts22 from "typescript";
 
 // src/rules/_uuid-predicate-witness.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES28, ASTUtils as ASTUtils14 } from "@typescript-eslint/utils";
-import ts18 from "typescript";
+import ts21 from "typescript";
 
 // src/rules/_native-runtime-unchanged.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES27, ASTUtils as ASTUtils13 } from "@typescript-eslint/utils";
@@ -4752,7 +5311,7 @@ function noArguments(node) {
 function installedZod(node, services) {
   const checker = services.program.getTypeChecker();
   const symbol = checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(node));
-  if (symbol === void 0 || (symbol.flags & ts18.SymbolFlags.Alias) === 0) return false;
+  if (symbol === void 0 || (symbol.flags & ts21.SymbolFlags.Alias) === 0) return false;
   const target = checker.getAliasedSymbol(symbol);
   const declarations = target.getDeclarations();
   return declarations !== void 0 && declarations.length > 0 && declarations.every((declaration) => {
@@ -4850,25 +5409,25 @@ function primitivePredicate(node, services) {
   if (node.async || node.generator || node.typeParameters !== void 0 || node.params.length !== 1 || annotation?.type !== AST_NODE_TYPES29.TSTypePredicate || annotation.asserts || annotation.parameterName.type !== AST_NODE_TYPES29.Identifier || annotation.typeAnnotation === void 0 || parameter?.type !== AST_NODE_TYPES29.Identifier || parameter.name !== annotation.parameterName.name || parameter.typeAnnotation === void 0) return void 0;
   const checker = services.program.getTypeChecker();
   const tsFunction = services.esTreeNodeToTSNodeMap.get(node);
-  if (ts19.isMethodDeclaration(tsFunction)) return void 0;
+  if (ts22.isMethodDeclaration(tsFunction)) return void 0;
   if (hasSeparatePredicateContract(tsFunction, checker)) return void 0;
   const target = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(annotation.typeAnnotation.typeAnnotation));
   const kind = primitiveKind2(target);
   const input = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(parameter));
-  const unsafe = ts19.TypeFlags.Any | ts19.TypeFlags.Never | ts19.TypeFlags.TypeParameter | ts19.TypeFlags.Conditional | ts19.TypeFlags.IndexedAccess;
+  const unsafe = ts22.TypeFlags.Any | ts22.TypeFlags.Never | ts22.TypeFlags.TypeParameter | ts22.TypeFlags.Conditional | ts22.TypeFlags.IndexedAccess;
   if (kind === void 0 || (input.flags & unsafe) !== 0 || !checker.isTypeAssignableTo(target, input)) return void 0;
   const expression = returnedExpression2(node);
   return expression === void 0 ? void 0 : { annotation, parameter, expression, kind, input, inputIsTarget: checker.isTypeAssignableTo(input, target) };
 }
 function primitiveKind2(type) {
-  if ((type.flags & ts19.TypeFlags.String) !== 0) return "string";
-  if ((type.flags & ts19.TypeFlags.Number) !== 0) return "number";
-  if ((type.flags & ts19.TypeFlags.BigInt) !== 0) return "bigint";
-  if ((type.flags & ts19.TypeFlags.Boolean) !== 0) return "boolean";
+  if ((type.flags & ts22.TypeFlags.String) !== 0) return "string";
+  if ((type.flags & ts22.TypeFlags.Number) !== 0) return "number";
+  if ((type.flags & ts22.TypeFlags.BigInt) !== 0) return "bigint";
+  if ((type.flags & ts22.TypeFlags.Boolean) !== 0) return "boolean";
   return void 0;
 }
 function numericWitnessInInput(value, input) {
-  return (input.isUnion() ? input.types : [input]).some((member3) => (member3.flags & (ts19.TypeFlags.Unknown | ts19.TypeFlags.Number)) !== 0 || Number.isFinite(value) && isNumberLiteralType(member3) && member3.value === value);
+  return (input.isUnion() ? input.types : [input]).some((member3) => (member3.flags & (ts22.TypeFlags.Unknown | ts22.TypeFlags.Number)) !== 0 || Number.isFinite(value) && isNumberLiteralType(member3) && member3.value === value);
 }
 function returnedExpression2(node) {
   if (node.body === void 0) return void 0;
@@ -4981,7 +5540,7 @@ import { AST_NODE_TYPES as AST_NODE_TYPES32, ASTUtils as ASTUtils18, ESLintUtils
 
 // src/rules/_boolean-selector-contract.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES30, ASTUtils as ASTUtils16 } from "@typescript-eslint/utils";
-import ts20 from "typescript";
+import ts23 from "typescript";
 var MEMBER_REFERENCES = /* @__PURE__ */ new WeakMap();
 function isEligibleBooleanSelector(identifier, sourceCode, services) {
   const owner = enclosingFunction(identifier);
@@ -4993,12 +5552,12 @@ function isEligibleBooleanSelector(identifier, sourceCode, services) {
   const definition = binding3?.defs[0];
   if (binding3?.defs.length !== 1 || definition?.type !== "Parameter" || definition.node !== owner || definition.name.type !== AST_NODE_TYPES30.Identifier || binding3.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
   const checker = services.program.getTypeChecker();
-  if ((checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(definition.name)).flags & ts20.TypeFlags.Boolean) === 0) return false;
+  if ((checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(definition.name)).flags & ts23.TypeFlags.Boolean) === 0) return false;
   const parameter = definition.name.parent.type === AST_NODE_TYPES30.AssignmentPattern ? definition.name.parent : definition.name;
   const index = owner.params.indexOf(parameter);
   if (index < 0 || isPureMapping(owner, sourceCode, services)) return false;
   const implementation = services.esTreeNodeToTSNodeMap.get(owner);
-  if (ts20.isSetAccessorDeclaration(implementation)) return false;
+  if (ts23.isSetAccessorDeclaration(implementation)) return false;
   const authority = { checker, index, implementation };
   if (hasDeclaredContract(authority) || hasMemberCallbackReference(authority, sourceCode, services)) return false;
   const callable = callableBinding2(owner, sourceCode);
@@ -5014,10 +5573,10 @@ function booleanContract(authority, type, independentlyAnnotated = false) {
   return (type === void 0 ? [] : authority.checker.getNonNullableType(type).getCallSignatures()).some((signature) => {
     const declaration = signature.declaration;
     const parameter = declaration?.parameters[authority.index];
-    if (declaration === void 0 || declaration === authority.implementation || parameter === void 0 || !ts20.isParameter(parameter) || parameter.type === void 0) return false;
-    if ((authority.checker.getTypeFromTypeNode(parameter.type).flags & ts20.TypeFlags.BooleanLike) !== 0) return true;
+    if (declaration === void 0 || declaration === authority.implementation || parameter === void 0 || !ts23.isParameter(parameter) || parameter.type === void 0) return false;
+    if ((authority.checker.getTypeFromTypeNode(parameter.type).flags & ts23.TypeFlags.BooleanLike) !== 0) return true;
     const instantiated = signature.getParameters()[authority.index];
-    return independentlyAnnotated && instantiated !== void 0 && (authority.checker.getTypeOfSymbolAtLocation(instantiated, declaration).flags & ts20.TypeFlags.BooleanLike) !== 0;
+    return independentlyAnnotated && instantiated !== void 0 && (authority.checker.getTypeOfSymbolAtLocation(instantiated, declaration).flags & ts23.TypeFlags.BooleanLike) !== 0;
   });
 }
 function callbackContract(authority, expression) {
@@ -5025,22 +5584,22 @@ function callbackContract(authority, expression) {
   if (booleanContract(authority, checker.getContextualType(expression))) return true;
   const value = outerTypedExpression(expression);
   const parent = value.parent;
-  if (ts20.isCallExpression(parent)) {
+  if (ts23.isCallExpression(parent)) {
     const index = parent.arguments.indexOf(value);
     const parameter = index < 0 ? void 0 : checker.getResolvedSignature(parent)?.declaration?.parameters[index];
-    return parameter !== void 0 && ts20.isParameter(parameter) && parameter.type !== void 0 && booleanContract(authority, checker.getTypeFromTypeNode(parameter.type), true);
+    return parameter !== void 0 && ts23.isParameter(parameter) && parameter.type !== void 0 && booleanContract(authority, checker.getTypeFromTypeNode(parameter.type), true);
   }
-  if (!ts20.isJsxExpression(parent) || !ts20.isJsxAttribute(parent.parent)) return false;
+  if (!ts23.isJsxExpression(parent) || !ts23.isJsxAttribute(parent.parent)) return false;
   const attribute = parent.parent;
-  if (checker.getSymbolAtLocation(attribute.name)?.declarations?.some((declaration) => (ts20.isPropertyDeclaration(declaration) || ts20.isPropertySignature(declaration)) && declaration.type !== void 0 && booleanContract(authority, checker.getTypeFromTypeNode(declaration.type), true)) === true) return true;
-  if (!ts20.isIdentifier(attribute.name)) return false;
+  if (checker.getSymbolAtLocation(attribute.name)?.declarations?.some((declaration) => (ts23.isPropertyDeclaration(declaration) || ts23.isPropertySignature(declaration)) && declaration.type !== void 0 && booleanContract(authority, checker.getTypeFromTypeNode(declaration.type), true)) === true) return true;
+  if (!ts23.isIdentifier(attribute.name)) return false;
   const opening = attribute.parent.parent;
   const propContract = (type) => {
     const property = checker.getPropertyOfType(type, attribute.name.getText());
     return property !== void 0 && booleanContract(authority, checker.getTypeOfSymbolAtLocation(property, attribute), true);
   };
   const props = checker.getResolvedSignature(opening)?.declaration?.parameters[0];
-  if (props !== void 0 && ts20.isParameter(props) && props.type !== void 0 && propContract(checker.getTypeFromTypeNode(props.type))) return true;
+  if (props !== void 0 && ts23.isParameter(props) && props.type !== void 0 && propContract(checker.getTypeFromTypeNode(props.type))) return true;
   return checker.getTypeAtLocation(opening.tagName).getCallSignatures().some((signature) => {
     const parameter = signature.getParameters()[0];
     return parameter !== void 0 && propContract(checker.getTypeOfSymbolAtLocation(parameter, opening.tagName));
@@ -5048,41 +5607,41 @@ function callbackContract(authority, expression) {
 }
 function outerTypedExpression(node) {
   let current = node;
-  while ((ts20.isParenthesizedExpression(current.parent) || ts20.isAsExpression(current.parent) || ts20.isTypeAssertionExpression(current.parent) || ts20.isNonNullExpression(current.parent) || ts20.isSatisfiesExpression(current.parent)) && current.parent.expression === current) current = current.parent;
+  while ((ts23.isParenthesizedExpression(current.parent) || ts23.isAsExpression(current.parent) || ts23.isTypeAssertionExpression(current.parent) || ts23.isNonNullExpression(current.parent) || ts23.isSatisfiesExpression(current.parent)) && current.parent.expression === current) current = current.parent;
   return current;
 }
 function hasDeclaredContract(authority) {
   const node = authority.implementation;
   const checker = authority.checker;
-  if (ts20.isArrowFunction(node) || ts20.isFunctionExpression(node)) {
+  if (ts23.isArrowFunction(node) || ts23.isFunctionExpression(node)) {
     if (callbackContract(authority, node)) return true;
     const binding3 = outerTypedExpression(node).parent;
-    if ((ts20.isVariableDeclaration(binding3) || ts20.isPropertyDeclaration(binding3)) && binding3.type !== void 0 && booleanContract(authority, checker.getTypeFromTypeNode(binding3.type), true)) return true;
-    return ts20.isPropertyDeclaration(binding3) && memberContract(authority, binding3);
+    if ((ts23.isVariableDeclaration(binding3) || ts23.isPropertyDeclaration(binding3)) && binding3.type !== void 0 && booleanContract(authority, checker.getTypeFromTypeNode(binding3.type), true)) return true;
+    return ts23.isPropertyDeclaration(binding3) && memberContract(authority, binding3);
   }
-  if (ts20.isMethodDeclaration(node)) return memberContract(authority, node);
-  if (!ts20.isFunctionDeclaration(node) || node.name === void 0) return false;
-  return checker.getSymbolAtLocation(node.name)?.declarations?.some((declaration) => declaration !== node && ts20.isFunctionDeclaration(declaration) && declaration.parameters[authority.index]?.type !== void 0) === true;
+  if (ts23.isMethodDeclaration(node)) return memberContract(authority, node);
+  if (!ts23.isFunctionDeclaration(node) || node.name === void 0) return false;
+  return checker.getSymbolAtLocation(node.name)?.declarations?.some((declaration) => declaration !== node && ts23.isFunctionDeclaration(declaration) && declaration.parameters[authority.index]?.type !== void 0) === true;
 }
 function memberContract(authority, member3) {
   const owner = member3.parent;
   const checker = authority.checker;
   const symbol = checker.getSymbolAtLocation(member3.name);
-  if (symbol === void 0 || ts20.isPrivateIdentifier(member3.name)) return false;
+  if (symbol === void 0 || ts23.isPrivateIdentifier(member3.name)) return false;
   const matches = (type, independentlyAnnotated = false) => {
     const property = type.getProperties().find((candidate2) => candidate2.escapedName === symbol.escapedName);
     return property !== void 0 && booleanContract(authority, checker.getTypeOfSymbolAtLocation(property, member3), independentlyAnnotated);
   };
-  if (ts20.isObjectLiteralExpression(owner)) {
+  if (ts23.isObjectLiteralExpression(owner)) {
     const contextual = checker.getContextualType(owner);
     const binding3 = outerTypedExpression(owner).parent;
-    if (ts20.isVariableDeclaration(binding3) && binding3.type !== void 0 && matches(checker.getTypeFromTypeNode(binding3.type), true)) return true;
+    if (ts23.isVariableDeclaration(binding3) && binding3.type !== void 0 && matches(checker.getTypeFromTypeNode(binding3.type), true)) return true;
     return contextual !== void 0 && matches(contextual);
   }
-  if (!ts20.isClassDeclaration(owner) && !ts20.isClassExpression(owner)) return false;
-  const modifiers = ts20.getCombinedModifierFlags(member3);
-  if ((modifiers & ts20.ModifierFlags.Private) !== 0) return false;
-  return owner.heritageClauses?.some((clause) => clause.types.some((heritage) => matches(checker.getTypeAtLocation((modifiers & ts20.ModifierFlags.Static) !== 0 ? heritage.expression : heritage), true))) === true;
+  if (!ts23.isClassDeclaration(owner) && !ts23.isClassExpression(owner)) return false;
+  const modifiers = ts23.getCombinedModifierFlags(member3);
+  if ((modifiers & ts23.ModifierFlags.Private) !== 0) return false;
+  return owner.heritageClauses?.some((clause) => clause.types.some((heritage) => matches(checker.getTypeAtLocation((modifiers & ts23.ModifierFlags.Static) !== 0 ? heritage.expression : heritage), true))) === true;
 }
 function callableBinding2(owner, sourceCode) {
   if (owner.type === AST_NODE_TYPES30.FunctionDeclaration && owner.id !== null) return ASTUtils16.findVariable(sourceCode.getScope(owner), owner.id.name);
@@ -5102,7 +5661,7 @@ function hasCallbackReference(binding3, authority, sourceCode, services, seen) {
     const jsxAttribute = parent?.type === AST_NODE_TYPES30.JSXExpressionContainer && parent.parent.type === AST_NODE_TYPES30.JSXAttribute;
     if (callArgument || jsxAttribute) {
       const expression = services.esTreeNodeToTSNodeMap.get(value);
-      if (ts20.isExpression(expression) && callbackContract(authority, expression)) return true;
+      if (ts23.isExpression(expression) && callbackContract(authority, expression)) return true;
     }
     if (parent?.type === AST_NODE_TYPES30.CallExpression && parent.callee === value && forwardedCallbackParameter(parent, authority, sourceCode, services)) return true;
     let selected = value;
@@ -5127,20 +5686,20 @@ function forwardedCallbackParameter(call, authority, sourceCode, services) {
   const binding3 = ASTUtils16.findVariable(sourceCode.getScope(argument), argument.name);
   const definition = binding3?.defs[0];
   if (binding3?.defs.length !== 1 || definition?.type !== "Parameter" || definition.node !== wrapper || definition.name.type !== AST_NODE_TYPES30.Identifier || binding3.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
-  if ((authority.checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(definition.name)).flags & ts20.TypeFlags.Boolean) === 0) return false;
+  if ((authority.checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(definition.name)).flags & ts23.TypeFlags.Boolean) === 0) return false;
   const parameter = definition.name.parent.type === AST_NODE_TYPES30.AssignmentPattern ? definition.name.parent : definition.name;
   const index = wrapper.params.indexOf(parameter);
   const implementation = services.esTreeNodeToTSNodeMap.get(wrapper);
-  return index >= 0 && (ts20.isArrowFunction(implementation) || ts20.isFunctionExpression(implementation)) && callbackContract({ checker: authority.checker, index, implementation }, implementation);
+  return index >= 0 && (ts23.isArrowFunction(implementation) || ts23.isFunctionExpression(implementation)) && callbackContract({ checker: authority.checker, index, implementation }, implementation);
 }
 function hasMemberCallbackReference(authority, sourceCode, services) {
   const node = authority.implementation;
-  const member3 = ts20.isMethodDeclaration(node) ? node : ts20.isArrowFunction(node) || ts20.isFunctionExpression(node) ? outerTypedExpression(node).parent : void 0;
-  if (member3 === void 0 || !ts20.isMethodDeclaration(member3) && !ts20.isPropertyDeclaration(member3) && !ts20.isPropertyAssignment(member3)) return false;
+  const member3 = ts23.isMethodDeclaration(node) ? node : ts23.isArrowFunction(node) || ts23.isFunctionExpression(node) ? outerTypedExpression(node).parent : void 0;
+  if (member3 === void 0 || !ts23.isMethodDeclaration(member3) && !ts23.isPropertyDeclaration(member3) && !ts23.isPropertyAssignment(member3)) return false;
   let references = MEMBER_REFERENCES.get(sourceCode);
   if (references === void 0) {
     let visit2 = function(current) {
-      if (ts20.isPropertyAccessExpression(current)) {
+      if (ts23.isPropertyAccessExpression(current)) {
         const target = authority.checker.getSymbolAtLocation(current.name);
         for (const declaration of target?.declarations ?? []) {
           const values = collected.get(declaration) ?? [];
@@ -5148,7 +5707,7 @@ function hasMemberCallbackReference(authority, sourceCode, services) {
           collected.set(declaration, values);
         }
       }
-      ts20.forEachChild(current, visit2);
+      ts23.forEachChild(current, visit2);
     };
     var visit = visit2;
     const collected = /* @__PURE__ */ new Map();
@@ -5159,14 +5718,14 @@ function hasMemberCallbackReference(authority, sourceCode, services) {
   return references.get(member3)?.some((reference) => {
     let value = outerTypedExpression(reference);
     const bind = value.parent;
-    if (ts20.isPropertyAccessExpression(bind) && bind.expression === value && bind.name.text === "bind" && ts20.isCallExpression(bind.parent) && bind.parent.expression === bind && bind.parent.arguments.length === 1) {
+    if (ts23.isPropertyAccessExpression(bind) && bind.expression === value && bind.name.text === "bind" && ts23.isCallExpression(bind.parent) && bind.parent.expression === bind && bind.parent.arguments.length === 1) {
       const declaration = authority.checker.getResolvedSignature(bind.parent)?.declaration;
       if (declaration === void 0 || !services.program.isSourceFileDefaultLibrary(declaration.getSourceFile())) return false;
       value = outerTypedExpression(bind.parent);
     }
     const parent = value.parent;
-    const callback = ts20.isCallExpression(parent) && parent.arguments.some((argument) => argument === value);
-    const jsx = ts20.isJsxExpression(parent) && ts20.isJsxAttribute(parent.parent);
+    const callback = ts23.isCallExpression(parent) && parent.arguments.some((argument) => argument === value);
+    const jsx = ts23.isJsxExpression(parent) && ts23.isJsxAttribute(parent.parent);
     return (callback || jsx) && callbackContract(authority, value);
   }) === true;
 }
@@ -5210,21 +5769,21 @@ function sameTarget(left, right, sourceCode, services, operation2) {
   if (!operation2) return true;
   const checker = services.program.getTypeChecker();
   const property = checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(left.property));
-  return property !== void 0 && property === checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(right.property)) && property.declarations?.every((declaration) => ts20.isMethodDeclaration(declaration)) === true;
+  return property !== void 0 && property === checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(right.property)) && property.declarations?.every((declaration) => ts23.isMethodDeclaration(declaration)) === true;
 }
 function pureValue(node, sourceCode, services) {
   const value = unwrapExpression(node);
   if (value.type === AST_NODE_TYPES30.MemberExpression && !value.computed) return value.object.type === AST_NODE_TYPES30.Super || pureValue(value.object, sourceCode, services);
   if (value.type === AST_NODE_TYPES30.ChainExpression) return pureValue(value.expression, sourceCode, services);
   if (value.type === AST_NODE_TYPES30.UnaryExpression && (value.operator === "!" || value.operator === "typeof" || value.operator === "void")) return pureValue(value.argument, sourceCode, services);
-  if (value.type === AST_NODE_TYPES30.UnaryExpression && (value.operator === "+" || value.operator === "-" || value.operator === "~")) return primitiveValue(value.argument, services) && pureValue(value.argument, sourceCode, services);
+  if (value.type === AST_NODE_TYPES30.UnaryExpression && (value.operator === "+" || value.operator === "-" || value.operator === "~")) return primitiveValue2(value.argument, services) && pureValue(value.argument, sourceCode, services);
   if (!ASTUtils16.hasSideEffect(value, sourceCode, { considerGetters: true, considerImplicitTypeConversion: true })) return true;
   if (value.type !== AST_NODE_TYPES30.BinaryExpression || value.left.type === AST_NODE_TYPES30.PrivateIdentifier) return false;
-  return primitiveValue(value.left, services) && primitiveValue(value.right, services) && pureValue(value.left, sourceCode, services) && pureValue(value.right, sourceCode, services);
+  return primitiveValue2(value.left, services) && primitiveValue2(value.right, services) && pureValue(value.left, sourceCode, services) && pureValue(value.right, sourceCode, services);
 }
-function primitiveValue(operand, services) {
+function primitiveValue2(operand, services) {
   const type = services.program.getTypeChecker().getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(operand));
-  return (type.isUnion() ? type.types : [type]).every((member3) => (member3.flags & (ts20.TypeFlags.StringLike | ts20.TypeFlags.NumberLike | ts20.TypeFlags.BooleanLike | ts20.TypeFlags.BigIntLike | ts20.TypeFlags.Null | ts20.TypeFlags.Undefined)) !== 0);
+  return (type.isUnion() ? type.types : [type]).every((member3) => (member3.flags & (ts23.TypeFlags.StringLike | ts23.TypeFlags.NumberLike | ts23.TypeFlags.BooleanLike | ts23.TypeFlags.BigIntLike | ts23.TypeFlags.Null | ts23.TypeFlags.Undefined)) !== 0);
 }
 
 // src/rules/_literal-selector-fix.ts
@@ -5458,7 +6017,7 @@ function isDirectTest(identifier) {
 // src/rules/no-invalid-zod-custom-parse.ts
 import { ASTUtils as ASTUtils19, AST_NODE_TYPES as AST_NODE_TYPES34, ESLintUtils as ESLintUtils15 } from "@typescript-eslint/utils";
 import { isBigIntLiteralType, isBooleanLiteralType, isNumberLiteralType as isNumberLiteralType2, isStringLiteralType } from "ts-api-utils";
-import ts21 from "typescript";
+import ts24 from "typescript";
 
 // src/rules/_import-specifier-name.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES33 } from "@typescript-eslint/utils";
@@ -5554,17 +6113,17 @@ function nativeZodDeclaration(signature) {
 }
 function primitiveDomain(type) {
   if (type.isUnion()) return type.types.every(primitiveDomain);
-  if ((type.flags & (ts21.TypeFlags.Enum | ts21.TypeFlags.EnumLiteral)) !== 0) return false;
-  const flags = ts21.TypeFlags.String | ts21.TypeFlags.Number | ts21.TypeFlags.BigInt | ts21.TypeFlags.BooleanLiteral | ts21.TypeFlags.StringLiteral | ts21.TypeFlags.NumberLiteral | ts21.TypeFlags.BigIntLiteral | ts21.TypeFlags.Null | ts21.TypeFlags.Undefined | ts21.TypeFlags.Never;
+  if ((type.flags & (ts24.TypeFlags.Enum | ts24.TypeFlags.EnumLiteral)) !== 0) return false;
+  const flags = ts24.TypeFlags.String | ts24.TypeFlags.Number | ts24.TypeFlags.BigInt | ts24.TypeFlags.BooleanLiteral | ts24.TypeFlags.StringLiteral | ts24.TypeFlags.NumberLiteral | ts24.TypeFlags.BigIntLiteral | ts24.TypeFlags.Null | ts24.TypeFlags.Undefined | ts24.TypeFlags.Never;
   return (type.flags & flags) !== 0;
 }
 function acceptsPrimitive(type, value) {
   if (type.isUnion()) return type.types.some((member3) => acceptsPrimitive(member3, value));
-  if (value === null) return (type.flags & ts21.TypeFlags.Null) !== 0;
-  if (typeof value === "string") return (type.flags & ts21.TypeFlags.String) !== 0 || isStringLiteralType(type) && type.value === value;
-  if (typeof value === "number") return (type.flags & ts21.TypeFlags.Number) !== 0 || isNumberLiteralType2(type) && type.value === value;
+  if (value === null) return (type.flags & ts24.TypeFlags.Null) !== 0;
+  if (typeof value === "string") return (type.flags & ts24.TypeFlags.String) !== 0 || isStringLiteralType(type) && type.value === value;
+  if (typeof value === "number") return (type.flags & ts24.TypeFlags.Number) !== 0 || isNumberLiteralType2(type) && type.value === value;
   if (typeof value === "boolean") return isBooleanLiteralType(type) && type.intrinsicName === String(value);
-  return (type.flags & ts21.TypeFlags.BigInt) !== 0 || isBigIntLiteralType(type) && bigintValue(type) === value;
+  return (type.flags & ts24.TypeFlags.BigInt) !== 0 || isBigIntLiteralType(type) && bigintValue(type) === value;
 }
 function bigintValue(type) {
   return BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`);
@@ -5581,7 +6140,7 @@ function primitiveLiteral(node) {
 
 // src/rules/no-contradictory-overload-return.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES35, ESLintUtils as ESLintUtils16 } from "@typescript-eslint/utils";
-import ts22 from "typescript";
+import ts25 from "typescript";
 var LIMIT = 32;
 var NO_CONTRADICTORY_OVERLOAD_RETURN_DOCUMENTATION = {
   summary: "Preserve the input/result relationship promised by literal overloads.",
@@ -5679,16 +6238,16 @@ function privateOverloadFix(sourceCode, filename, node, implementation, proof, s
   return edits.length === 0 ? null : (fixer) => edits.map((edit) => fixer.replaceText(edit.node, edit.text));
 }
 function directResultSyntax(node) {
-  if (ts22.isParenthesizedTypeNode(node)) return directResultSyntax(node.type);
-  if (ts22.isUnionTypeNode(node)) return node.types.length <= LIMIT && node.types.every(directResultSyntax);
-  if (!ts22.isTypeLiteralNode(node)) return primitiveResultSyntax(node);
-  return node.members.every((member3) => ts22.isPropertySignature(member3) && propertyKey(member3.name) !== void 0 && member3.type !== void 0 && primitiveResultSyntax(member3.type));
+  if (ts25.isParenthesizedTypeNode(node)) return directResultSyntax(node.type);
+  if (ts25.isUnionTypeNode(node)) return node.types.length <= LIMIT && node.types.every(directResultSyntax);
+  if (!ts25.isTypeLiteralNode(node)) return primitiveResultSyntax(node);
+  return node.members.every((member3) => ts25.isPropertySignature(member3) && propertyKey(member3.name) !== void 0 && member3.type !== void 0 && primitiveResultSyntax(member3.type));
 }
 function primitiveResultSyntax(node) {
-  if (ts22.isParenthesizedTypeNode(node)) return primitiveResultSyntax(node.type);
-  if (ts22.isUnionTypeNode(node)) return node.types.length <= LIMIT && node.types.every(primitiveResultSyntax);
-  if (ts22.isLiteralTypeNode(node)) return primitiveLiteral2(node.literal) !== void 0;
-  return node.kind === ts22.SyntaxKind.StringKeyword || node.kind === ts22.SyntaxKind.NumberKeyword || node.kind === ts22.SyntaxKind.BooleanKeyword || node.kind === ts22.SyntaxKind.UndefinedKeyword || node.kind === ts22.SyntaxKind.NeverKeyword;
+  if (ts25.isParenthesizedTypeNode(node)) return primitiveResultSyntax(node.type);
+  if (ts25.isUnionTypeNode(node)) return node.types.length <= LIMIT && node.types.every(primitiveResultSyntax);
+  if (ts25.isLiteralTypeNode(node)) return primitiveLiteral2(node.literal) !== void 0;
+  return node.kind === ts25.SyntaxKind.StringKeyword || node.kind === ts25.SyntaxKind.NumberKeyword || node.kind === ts25.SyntaxKind.BooleanKeyword || node.kind === ts25.SyntaxKind.UndefinedKeyword || node.kind === ts25.SyntaxKind.NeverKeyword;
 }
 function branchResultType(branch, sourceCode, services) {
   const valueType = (literal2) => typeof literal2.value === "string" ? sourceCode.getText(services.tsNodeToESTreeNodeMap.get(literal2.node)) : String(literal2.value);
@@ -5697,11 +6256,11 @@ function branchResultType(branch, sourceCode, services) {
 }
 function implementationProof(node, checker) {
   const parameter = directParameter(node);
-  if (!ts22.isSourceFile(node.parent) || node.name === void 0 || node.body?.statements.length !== 1 || node.typeParameters !== void 0 || node.asteriskToken !== void 0 || node.modifiers?.some((modifier) => modifier.kind === ts22.SyntaxKind.AsyncKeyword) || parameter === void 0) return void 0;
+  if (!ts25.isSourceFile(node.parent) || node.name === void 0 || node.body?.statements.length !== 1 || node.typeParameters !== void 0 || node.asteriskToken !== void 0 || node.modifiers?.some((modifier) => modifier.kind === ts25.SyntaxKind.AsyncKeyword) || parameter === void 0) return void 0;
   const returned2 = node.body.statements[0];
-  if (returned2 === void 0 || !ts22.isReturnStatement(returned2) || returned2.expression === void 0) return void 0;
+  if (returned2 === void 0 || !ts25.isReturnStatement(returned2) || returned2.expression === void 0) return void 0;
   const expression = unparen(returned2.expression);
-  if (!ts22.isConditionalExpression(expression)) return void 0;
+  if (!ts25.isConditionalExpression(expression)) return void 0;
   const condition2 = equality(expression.condition, checker.getSymbolAtLocation(parameter.name), checker);
   const yes = branchValue(expression.whenTrue);
   const no = branchValue(expression.whenFalse);
@@ -5715,21 +6274,21 @@ function implementationProof(node, checker) {
 }
 function directParameter(node) {
   const parameter = node.parameters[0];
-  if (node.parameters.length !== 1 || parameter === void 0 || !ts22.isIdentifier(parameter.name) || parameter.name.text === "this" || parameter.type === void 0 || parameter.questionToken !== void 0 || parameter.dotDotDotToken !== void 0 || parameter.initializer !== void 0) return void 0;
+  if (node.parameters.length !== 1 || parameter === void 0 || !ts25.isIdentifier(parameter.name) || parameter.name.text === "this" || parameter.type === void 0 || parameter.questionToken !== void 0 || parameter.dotDotDotToken !== void 0 || parameter.initializer !== void 0) return void 0;
   return { name: parameter.name, type: parameter.type };
 }
 function overloadCases(node, implementationOutput, checker) {
   const declarations = node.name === void 0 ? void 0 : checker.getSymbolAtLocation(node.name)?.declarations;
-  if (declarations === void 0 || declarations.length < 3 || declarations.length > LIMIT + 1 || declarations.some((declaration) => !ts22.isFunctionDeclaration(declaration))) return void 0;
+  if (declarations === void 0 || declarations.length < 3 || declarations.length > LIMIT + 1 || declarations.some((declaration) => !ts25.isFunctionDeclaration(declaration))) return void 0;
   const cases = [];
   const seen = /* @__PURE__ */ new Set();
   const implementationParameter = directParameter(node);
   if (implementationParameter === void 0) return void 0;
   const implementationInput = checker.getTypeAtLocation(implementationParameter.type);
   for (const declaration of declarations) {
-    if (!ts22.isFunctionDeclaration(declaration) || declaration === node) continue;
+    if (!ts25.isFunctionDeclaration(declaration) || declaration === node) continue;
     const parameter = directParameter(declaration);
-    if (declaration.body !== void 0 || declaration.typeParameters !== void 0 || parameter === void 0 || !ts22.isLiteralTypeNode(parameter.type)) return void 0;
+    if (declaration.body !== void 0 || declaration.typeParameters !== void 0 || parameter === void 0 || !ts25.isLiteralTypeNode(parameter.type)) return void 0;
     const input = primitiveLiteral2(parameter.type.literal);
     const signature = checker.getSignatureFromDeclaration(declaration);
     if (input === void 0 || seen.has(input.value) || signature === void 0 || !checker.isTypeAssignableTo(checker.getTypeAtLocation(parameter.type), implementationInput)) return void 0;
@@ -5742,11 +6301,11 @@ function overloadCases(node, implementationOutput, checker) {
 }
 function equality(expression, parameter, checker) {
   const value = unparen(expression);
-  if (parameter === void 0 || !ts22.isBinaryExpression(value) || value.operatorToken.kind !== ts22.SyntaxKind.EqualsEqualsEqualsToken && value.operatorToken.kind !== ts22.SyntaxKind.ExclamationEqualsEqualsToken) return void 0;
+  if (parameter === void 0 || !ts25.isBinaryExpression(value) || value.operatorToken.kind !== ts25.SyntaxKind.EqualsEqualsEqualsToken && value.operatorToken.kind !== ts25.SyntaxKind.ExclamationEqualsEqualsToken) return void 0;
   for (const [tested, expected] of [[value.left, value.right], [value.right, value.left]]) {
     const named3 = unparen(tested);
     const condition2 = primitiveLiteral2(expected);
-    if (ts22.isIdentifier(named3) && checker.getSymbolAtLocation(named3) === parameter && condition2 !== void 0) return { condition: condition2, equal: value.operatorToken.kind === ts22.SyntaxKind.EqualsEqualsEqualsToken };
+    if (ts25.isIdentifier(named3) && checker.getSymbolAtLocation(named3) === parameter && condition2 !== void 0) return { condition: condition2, equal: value.operatorToken.kind === ts25.SyntaxKind.EqualsEqualsEqualsToken };
   }
   return void 0;
 }
@@ -5754,10 +6313,10 @@ function branchValue(expression) {
   const node = unparen(expression);
   const literal2 = primitiveLiteral2(node);
   if (literal2 !== void 0) return { kind: "literal", node, value: literal2 };
-  if (!ts22.isObjectLiteralExpression(node) || node.properties.length > LIMIT) return void 0;
+  if (!ts25.isObjectLiteralExpression(node) || node.properties.length > LIMIT) return void 0;
   const values = /* @__PURE__ */ new Map();
   for (const property of node.properties) {
-    if (!ts22.isPropertyAssignment(property)) return void 0;
+    if (!ts25.isPropertyAssignment(property)) return void 0;
     const name = propertyKey(property.name);
     const value = primitiveLiteral2(property.initializer);
     if (name === void 0 || name === "__proto__" || values.has(name) || value === void 0) return void 0;
@@ -5781,30 +6340,30 @@ function mismatches(branch, expected, checker) {
 }
 function plainPrimitive(type) {
   const members = type.isUnion() ? type.types : [type];
-  const allowed = ts22.TypeFlags.String | ts22.TypeFlags.StringLiteral | ts22.TypeFlags.Number | ts22.TypeFlags.NumberLiteral | ts22.TypeFlags.BooleanLiteral | ts22.TypeFlags.Null | ts22.TypeFlags.Undefined | ts22.TypeFlags.Never;
-  return members.length <= LIMIT && members.every((member3) => (member3.flags & allowed) !== 0 && (member3.flags & (ts22.TypeFlags.Enum | ts22.TypeFlags.EnumLiteral)) === 0);
+  const allowed = ts25.TypeFlags.String | ts25.TypeFlags.StringLiteral | ts25.TypeFlags.Number | ts25.TypeFlags.NumberLiteral | ts25.TypeFlags.BooleanLiteral | ts25.TypeFlags.Null | ts25.TypeFlags.Undefined | ts25.TypeFlags.Never;
+  return members.length <= LIMIT && members.every((member3) => (member3.flags & allowed) !== 0 && (member3.flags & (ts25.TypeFlags.Enum | ts25.TypeFlags.EnumLiteral)) === 0);
 }
 function primitiveLiteral2(expression) {
   const node = unparen(expression);
-  if (ts22.isStringLiteral(node)) return { node, value: node.text };
-  if (node.kind === ts22.SyntaxKind.TrueKeyword) return { node, value: true };
-  if (node.kind === ts22.SyntaxKind.FalseKeyword) return { node, value: false };
-  if (node.kind === ts22.SyntaxKind.NullKeyword) return { node, value: null };
-  if (ts22.isNumericLiteral(node) && Number.isFinite(Number(node.text))) return { node, value: Number(node.text) };
-  if (ts22.isPrefixUnaryExpression(node) && (node.operator === ts22.SyntaxKind.MinusToken || node.operator === ts22.SyntaxKind.PlusToken) && ts22.isNumericLiteral(node.operand)) {
-    const value = Number(node.operand.text) * (node.operator === ts22.SyntaxKind.MinusToken ? -1 : 1);
+  if (ts25.isStringLiteral(node)) return { node, value: node.text };
+  if (node.kind === ts25.SyntaxKind.TrueKeyword) return { node, value: true };
+  if (node.kind === ts25.SyntaxKind.FalseKeyword) return { node, value: false };
+  if (node.kind === ts25.SyntaxKind.NullKeyword) return { node, value: null };
+  if (ts25.isNumericLiteral(node) && Number.isFinite(Number(node.text))) return { node, value: Number(node.text) };
+  if (ts25.isPrefixUnaryExpression(node) && (node.operator === ts25.SyntaxKind.MinusToken || node.operator === ts25.SyntaxKind.PlusToken) && ts25.isNumericLiteral(node.operand)) {
+    const value = Number(node.operand.text) * (node.operator === ts25.SyntaxKind.MinusToken ? -1 : 1);
     if (Number.isFinite(value)) return { node, value };
   }
   return void 0;
 }
 function propertyKey(name) {
-  if (ts22.isIdentifier(name) || ts22.isStringLiteral(name)) return name.text;
-  if (ts22.isNumericLiteral(name) && Number.isFinite(Number(name.text))) return String(Number(name.text));
+  if (ts25.isIdentifier(name) || ts25.isStringLiteral(name)) return name.text;
+  if (ts25.isNumericLiteral(name) && Number.isFinite(Number(name.text))) return String(Number(name.text));
   return void 0;
 }
 function unparen(expression) {
   let node = expression;
-  while (ts22.isParenthesizedExpression(node)) node = node.expression;
+  while (ts25.isParenthesizedExpression(node)) node = node.expression;
   return node;
 }
 
@@ -12412,7 +12971,7 @@ import {
   ASTUtils as ASTUtils38,
   ESLintUtils as ESLintUtils17
 } from "@typescript-eslint/utils";
-import ts23 from "typescript";
+import ts26 from "typescript";
 
 // src/rules/_existing-domain-comparison-fix.ts
 import {
@@ -12610,7 +13169,7 @@ var EQUALITY_OPERATORS = /* @__PURE__ */ new Set([
   "==",
   "==="
 ]);
-var PRIMITIVE_FLAGS = ts23.TypeFlags.BigIntLike | ts23.TypeFlags.BooleanLike | ts23.TypeFlags.ESSymbolLike | ts23.TypeFlags.Never | ts23.TypeFlags.Null | ts23.TypeFlags.NumberLike | ts23.TypeFlags.StringLike | ts23.TypeFlags.Undefined | ts23.TypeFlags.Void;
+var PRIMITIVE_FLAGS = ts26.TypeFlags.BigIntLike | ts26.TypeFlags.BooleanLike | ts26.TypeFlags.ESSymbolLike | ts26.TypeFlags.Never | ts26.TypeFlags.Null | ts26.TypeFlags.NumberLike | ts26.TypeFlags.StringLike | ts26.TypeFlags.Undefined | ts26.TypeFlags.Void;
 function unwrapComparisonExpression(node) {
   let current = unwrapExpression(node);
   while (current.type === AST_NODE_TYPES68.ChainExpression) {
@@ -12665,7 +13224,7 @@ function typeMayContainObject(type, checker) {
     return type.types.some((member3) => typeMayContainObject(member3, checker));
   }
   if ((type.flags & PRIMITIVE_FLAGS) !== 0) return false;
-  if ((type.flags & (ts23.TypeFlags.Any | ts23.TypeFlags.Unknown | ts23.TypeFlags.TypeParameter)) !== 0) {
+  if ((type.flags & (ts26.TypeFlags.Any | ts26.TypeFlags.Unknown | ts26.TypeFlags.TypeParameter)) !== 0) {
     return true;
   }
   if (checker.isArrayType(type) || checker.isTupleType(type)) {
@@ -12673,7 +13232,7 @@ function typeMayContainObject(type, checker) {
     return elements.some((element) => typeMayContainObject(element, checker));
   }
   const symbolName = type.getSymbol()?.getName();
-  if ((symbolName === "Array" || symbolName === "ReadonlyArray") && (type.flags & ts23.TypeFlags.Object) !== 0) {
+  if ((symbolName === "Array" || symbolName === "ReadonlyArray") && (type.flags & ts26.TypeFlags.Object) !== 0) {
     const elements = checker.getTypeArguments(type);
     return elements.length === 0 || elements.some((element) => typeMayContainObject(element, checker));
   }
@@ -13124,7 +13683,7 @@ function zeroBoundSemantic(method) {
 import {
   ESLintUtils as ESLintUtils18
 } from "@typescript-eslint/utils";
-import * as ts24 from "typescript";
+import * as ts27 from "typescript";
 
 // src/rules/_collection-property-fix.ts
 import {
@@ -13227,7 +13786,7 @@ function isDefaultLibraryCollection(node, services) {
   const checker = services.program.getTypeChecker();
   const tsNode = services.esTreeNodeToTSNodeMap.get(node);
   const type = checker.getTypeAtLocation(tsNode);
-  if ((type.flags & (ts24.TypeFlags.Any | ts24.TypeFlags.Unknown | ts24.TypeFlags.Never | ts24.TypeFlags.TypeParameter | ts24.TypeFlags.Union | ts24.TypeFlags.Intersection)) !== 0) {
+  if ((type.flags & (ts27.TypeFlags.Any | ts27.TypeFlags.Unknown | ts27.TypeFlags.Never | ts27.TypeFlags.TypeParameter | ts27.TypeFlags.Union | ts27.TypeFlags.Intersection)) !== 0) {
     return false;
   }
   return isDefaultLibraryCollectionSymbol(type.getSymbol(), services);
@@ -13238,7 +13797,7 @@ function isDefaultLibraryCollectionSymbol(symbol, services) {
   return declarations.length > 0 && declarations.every(
     (declaration) => services.program.isSourceFileDefaultLibrary(declaration.getSourceFile())
   ) && declarations.some(
-    (declaration) => ts24.isInterfaceDeclaration(declaration) && declaration.name.text === symbol.name
+    (declaration) => ts27.isInterfaceDeclaration(declaration) && declaration.name.text === symbol.name
   );
 }
 var no_in_operator_on_built_in_collections_default = createRule({
@@ -13558,7 +14117,7 @@ import {
   AST_NODE_TYPES as AST_NODE_TYPES74,
   ESLintUtils as ESLintUtils19
 } from "@typescript-eslint/utils";
-import * as ts25 from "typescript";
+import * as ts28 from "typescript";
 
 // src/rules/_class-private.ts
 import {
@@ -13730,15 +14289,15 @@ function candidate(member3) {
 }
 function interfaceNames(services, owner) {
   const tsOwner = services.esTreeNodeToTSNodeMap.get(owner);
-  if (!ts25.isClassDeclaration(tsOwner) && !ts25.isClassExpression(tsOwner)) return null;
-  const implemented = tsOwner.heritageClauses?.filter((clause) => clause.token === ts25.SyntaxKind.ImplementsKeyword) ?? [];
+  if (!ts28.isClassDeclaration(tsOwner) && !ts28.isClassExpression(tsOwner)) return null;
+  const implemented = tsOwner.heritageClauses?.filter((clause) => clause.token === ts28.SyntaxKind.ImplementsKeyword) ?? [];
   if (implemented.length === 0) return null;
   const checker = services.program.getTypeChecker();
   const names = /* @__PURE__ */ new Set();
   for (const clause of implemented) {
     for (const contract of clause.types) {
       const type = checker.getTypeAtLocation(contract);
-      if ((type.flags & (ts25.TypeFlags.Any | ts25.TypeFlags.Unknown)) !== 0) return null;
+      if ((type.flags & (ts28.TypeFlags.Any | ts28.TypeFlags.Unknown)) !== 0) return null;
       for (const property of checker.getPropertiesOfType(type)) names.add(property.getName());
     }
   }
@@ -14905,7 +15464,7 @@ function tupleFields(helper) {
   const values = [];
   for (const [index, field] of tuple.elementTypes.entries()) {
     const value = returned2.argument.elements[index];
-    if (field.type !== AST_NODE_TYPES81.TSNamedTupleMember || field.optional || value?.type !== AST_NODE_TYPES81.Literal || !primitiveValue2(field.elementType, value) || UNSAFE_NAMES.has(field.label.name) || labels.some((label) => label.name === field.label.name))
+    if (field.type !== AST_NODE_TYPES81.TSNamedTupleMember || field.optional || value?.type !== AST_NODE_TYPES81.Literal || !primitiveValue3(field.elementType, value) || UNSAFE_NAMES.has(field.label.name) || labels.some((label) => label.name === field.label.name))
       return null;
     labels.push(field.label);
     types.push(field.elementType);
@@ -14913,7 +15472,7 @@ function tupleFields(helper) {
   }
   return { labels, types, values, returned: returned2.argument };
 }
-function primitiveValue2(type, value) {
+function primitiveValue3(type, value) {
   switch (type.type) {
     case AST_NODE_TYPES81.TSStringKeyword:
       return typeof value.value === "string";
@@ -21004,7 +21563,7 @@ import {
   AST_NODE_TYPES as AST_NODE_TYPES107,
   ASTUtils as ASTUtils65
 } from "@typescript-eslint/utils";
-import * as ts26 from "typescript";
+import * as ts29 from "typescript";
 var NO_ZOD_NATIVE_ENUM_DOCUMENTATION = {
   summary: 'Disallow `z.nativeEnum()` (and `z.enum()` over a TypeScript enum); use `z.enum(["a", "b"])` with a string-literal union instead.',
   rationale: "The project prefers literal-first schema definitions. nativeEnum also accepts plain enum-like objects, so this is an explicit declaration policy, not proof that every call duplicates a TypeScript enum's runtime object.",
@@ -21113,7 +21672,7 @@ function resolvesToLocalEnum(node, scope) {
   }
   return false;
 }
-var ENUM_SYMBOL_FLAGS = ts26.SymbolFlags.RegularEnum | ts26.SymbolFlags.ConstEnum | ts26.SymbolFlags.Enum;
+var ENUM_SYMBOL_FLAGS = ts29.SymbolFlags.RegularEnum | ts29.SymbolFlags.ConstEnum | ts29.SymbolFlags.Enum;
 function resolvesToImportedEnum(node, services) {
   const checker = services.program.getTypeChecker();
   const tsNode = services.esTreeNodeToTSNodeMap.get(node);
@@ -21121,7 +21680,7 @@ function resolvesToImportedEnum(node, services) {
   if (symbol === void 0) {
     return false;
   }
-  if ((symbol.flags & ts26.SymbolFlags.Alias) !== 0) {
+  if ((symbol.flags & ts29.SymbolFlags.Alias) !== 0) {
     symbol = checker.getAliasedSymbol(symbol);
   }
   return (symbol.flags & ENUM_SYMBOL_FLAGS) !== 0;
@@ -24766,7 +25325,7 @@ var OPERATIONAL_ROLES = /* @__PURE__ */ new Set([
   "timeout",
   "interval"
 ]);
-var MAX_ALIAS_DEPTH = 16;
+var MAX_ALIAS_DEPTH2 = 16;
 var PREFER_NOMINAL_ID_TYPES_DOCUMENTATION = {
   defaultLevel: "error",
   summary: "Distinguish identifier roles sharing primitive types at callable boundaries.",
@@ -24864,7 +25423,7 @@ function typeDefinitions(node, context) {
   return [];
 }
 function rawCarrier(node, context, depth = 0) {
-  if (node === void 0 || depth >= MAX_ALIAS_DEPTH) return void 0;
+  if (node === void 0 || depth >= MAX_ALIAS_DEPTH2) return void 0;
   switch (node.type) {
     case AST_NODE_TYPES124.TSStringKeyword:
       return "string";
@@ -26355,7 +26914,7 @@ import {
   ASTUtils as ASTUtils83,
   ESLintUtils as ESLintUtils22
 } from "@typescript-eslint/utils";
-import ts27 from "typescript";
+import ts30 from "typescript";
 var PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION = {
   summary: "Prefer an explicit nullish predicate when `filter(Boolean)` removes only nullish values but does not narrow the result type.",
   rationale: "An explicit nullish predicate preserves the same runtime elements while letting TypeScript remove `null` and `undefined` from the result.",
@@ -26418,23 +26977,23 @@ function isBuiltinArrayFilter(node, services) {
   const symbol = checker.getSymbolAtLocation(property) ?? checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node.object)).getProperty("filter");
   return symbol?.declarations?.some((declaration) => {
     const owner = declaration.parent;
-    return ts27.isInterfaceDeclaration(owner) && (owner.name.text === "Array" || owner.name.text === "ReadonlyArray") && services.program.isSourceFileDefaultLibrary(owner.getSourceFile());
+    return ts30.isInterfaceDeclaration(owner) && (owner.name.text === "Array" || owner.name.text === "ReadonlyArray") && services.program.isSourceFileDefaultLibrary(owner.getSourceFile());
   }) ?? false;
 }
 function arrayElementType(node, services) {
   const checker = services.program.getTypeChecker();
   const receiver = services.esTreeNodeToTSNodeMap.get(node);
-  return checker.getIndexTypeOfType(checker.getTypeAtLocation(receiver), ts27.IndexKind.Number) ?? null;
+  return checker.getIndexTypeOfType(checker.getTypeAtLocation(receiver), ts30.IndexKind.Number) ?? null;
 }
-var NULLISH_FLAGS = ts27.TypeFlags.Null | ts27.TypeFlags.Undefined;
-var UNKNOWN_FLAGS = ts27.TypeFlags.Any | ts27.TypeFlags.Unknown | ts27.TypeFlags.TypeParameter | ts27.TypeFlags.Intersection | ts27.TypeFlags.Enum | ts27.TypeFlags.EnumLiteral;
+var NULLISH_FLAGS = ts30.TypeFlags.Null | ts30.TypeFlags.Undefined;
+var UNKNOWN_FLAGS = ts30.TypeFlags.Any | ts30.TypeFlags.Unknown | ts30.TypeFlags.TypeParameter | ts30.TypeFlags.Intersection | ts30.TypeFlags.Enum | ts30.TypeFlags.EnumLiteral;
 function isNullishPlusTruthy(type, checker, falsyBrowserObject) {
   const members = type.isUnion() ? type.types : [type];
   let sawNullish = false;
   for (const member3 of members) {
     if ((member3.flags & NULLISH_FLAGS) !== 0) {
       sawNullish = true;
-    } else if ((member3.flags & ts27.TypeFlags.Never) === 0 && !isProvablyTruthy(member3, checker, falsyBrowserObject)) {
+    } else if ((member3.flags & ts30.TypeFlags.Never) === 0 && !isProvablyTruthy(member3, checker, falsyBrowserObject)) {
       return false;
     }
   }
@@ -26442,7 +27001,7 @@ function isNullishPlusTruthy(type, checker, falsyBrowserObject) {
 }
 function isProvablyTruthy(type, checker, falsyBrowserObject) {
   if ((type.flags & UNKNOWN_FLAGS) !== 0) return false;
-  if ((type.flags & ts27.TypeFlags.Object) !== 0) {
+  if ((type.flags & ts30.TypeFlags.Object) !== 0) {
     if (falsyBrowserObject !== null && checker.isTypeAssignableTo(falsyBrowserObject, type)) return false;
     return ![
       checker.getStringType(),
@@ -26451,18 +27010,18 @@ function isProvablyTruthy(type, checker, falsyBrowserObject) {
       checker.getBooleanType()
     ].some((primitive) => checker.isTypeAssignableTo(primitive, type));
   }
-  if ((type.flags & (ts27.TypeFlags.ESSymbol | ts27.TypeFlags.UniqueESSymbol)) !== 0) return true;
-  if ((type.flags & ts27.TypeFlags.BooleanLiteral) !== 0) {
+  if ((type.flags & (ts30.TypeFlags.ESSymbol | ts30.TypeFlags.UniqueESSymbol)) !== 0) return true;
+  if ((type.flags & ts30.TypeFlags.BooleanLiteral) !== 0) {
     return type.intrinsicName === "true";
   }
-  if ((type.flags & ts27.TypeFlags.StringLiteral) !== 0) {
+  if ((type.flags & ts30.TypeFlags.StringLiteral) !== 0) {
     return type.value.length > 0;
   }
-  if ((type.flags & ts27.TypeFlags.NumberLiteral) !== 0) {
+  if ((type.flags & ts30.TypeFlags.NumberLiteral) !== 0) {
     const value = type.value;
     return value !== 0 && !Number.isNaN(value);
   }
-  if ((type.flags & ts27.TypeFlags.BigIntLiteral) !== 0) {
+  if ((type.flags & ts30.TypeFlags.BigIntLiteral) !== 0) {
     return type.value.base10Value !== "0";
   }
   return false;
@@ -26518,7 +27077,7 @@ var prefer_nullish_filter_predicate_default = createRule({
     if (services === null) return {};
     const program = services.program;
     const checker = program.getTypeChecker();
-    const browserCollection = checker.resolveName("HTMLAllCollection", void 0, ts27.SymbolFlags.Type, false);
+    const browserCollection = checker.resolveName("HTMLAllCollection", void 0, ts30.SymbolFlags.Type, false);
     const falsyBrowserObject = browserCollection?.declarations?.some((declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile())) === true ? checker.getDeclaredTypeOfSymbol(browserCollection) : null;
     return {
       CallExpression(node) {
@@ -26556,7 +27115,7 @@ import {
   ESLintUtils as ESLintUtils23,
   AST_NODE_TYPES as AST_NODE_TYPES133
 } from "@typescript-eslint/utils";
-import * as ts28 from "typescript";
+import * as ts31 from "typescript";
 var PREFER_AWAIT_IN_ASYNC_RETURN_DOCUMENTATION = {
   summary: "Prefer explicit `await` for proven Promise `.then` calls; the default scope checks direct async returns.",
   rationale: "Promise callback chains mix explicit async control flow with nested callbacks, making sequencing and failure handling harder to read.",
@@ -26640,7 +27199,7 @@ function isProvenPromiseLike(node, services) {
   return members.every((member3) => isBuiltInPromiseType(member3, services));
 }
 function isBuiltInPromiseType(type, services) {
-  if ((type.flags & (ts28.TypeFlags.Any | ts28.TypeFlags.Unknown | ts28.TypeFlags.Never)) !== 0) {
+  if ((type.flags & (ts31.TypeFlags.Any | ts31.TypeFlags.Unknown | ts31.TypeFlags.Never)) !== 0) {
     return false;
   }
   const thenSymbol = services.program.getTypeChecker().getPropertyOfType(type, "then");
@@ -26649,7 +27208,7 @@ function isBuiltInPromiseType(type, services) {
   return declarations.every(
     (declaration) => {
       let owner = declaration.parent;
-      while (owner !== void 0 && !ts28.isInterfaceDeclaration(owner)) {
+      while (owner !== void 0 && !ts31.isInterfaceDeclaration(owner)) {
         owner = owner.parent;
       }
       return owner !== void 0 && (owner.name.text === "Promise" || owner.name.text === "PromiseLike") && services.program.isSourceFileDefaultLibrary(owner.getSourceFile());
@@ -27433,7 +27992,7 @@ var prefer_shared_zod_enum_default = createRule({
 
 // src/rules/prefer-switch-for-repeated-equality.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES137, ASTUtils as ASTUtils88, ESLintUtils as ESLintUtils24 } from "@typescript-eslint/utils";
-import ts29 from "typescript";
+import ts32 from "typescript";
 var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
   defaultLevel: "error",
   summary: "Prefer switch over long if/else-if chains that compare one value for strict equality.",
@@ -27513,7 +28072,7 @@ function hasUnsafeSwitchControl(node) {
 function hasOpenDiscriminant(node, services) {
   if (services === null) return false;
   const type = services.program.getTypeChecker().getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
-  const openFlags = ts29.TypeFlags.Any | ts29.TypeFlags.Unknown | ts29.TypeFlags.String | ts29.TypeFlags.Number | ts29.TypeFlags.BigInt | ts29.TypeFlags.ESSymbol;
+  const openFlags = ts32.TypeFlags.Any | ts32.TypeFlags.Unknown | ts32.TypeFlags.String | ts32.TypeFlags.Number | ts32.TypeFlags.BigInt | ts32.TypeFlags.ESSymbol;
   return (type.isUnion() ? type.types : [type]).some((part) => (part.flags & openFlags) !== 0);
 }
 var prefer_switch_for_repeated_equality_default = createRule({
@@ -29711,14 +30270,14 @@ import {
   AST_NODE_TYPES as AST_NODE_TYPES143,
   ESLintUtils as ESLintUtils25
 } from "@typescript-eslint/utils";
-import ts32 from "typescript";
+import ts35 from "typescript";
 
 // src/rules/_equivalent-zod-output-contracts.ts
 import { isPropertyReadonlyInType, isTupleTypeReference, isTypeReference as isTypeReference3 } from "ts-api-utils";
-import ts30 from "typescript";
+import ts33 from "typescript";
 var MAX_CONTRACT_PAIRS = 128;
 var MAX_UNION_MEMBERS = 16;
-var UNSAFE_TYPES = ts30.TypeFlags.Any | ts30.TypeFlags.Unknown | ts30.TypeFlags.Never;
+var UNSAFE_TYPES = ts33.TypeFlags.Any | ts33.TypeFlags.Unknown | ts33.TypeFlags.Never;
 function equivalentZodOutputContracts(checker, parsed, contract) {
   const comparison2 = { checker, pending: [[parsed, contract]], seen: /* @__PURE__ */ new Map(), pairs: 0 };
   while (comparison2.pending.length > 0) {
@@ -29778,8 +30337,8 @@ function equivalentContainers(comparison2, left, right) {
   const rightTuple = isTupleTypeReference(right);
   if (leftTuple !== rightTuple) return false;
   if (leftTuple && rightTuple && (left.target.readonly !== right.target.readonly || left.target.elementFlags.length !== right.target.elementFlags.length || left.target.elementFlags.some((flag, index) => flag !== right.target.elementFlags[index]))) return false;
-  const leftIndex = comparison2.checker.getIndexInfoOfType(left, ts30.IndexKind.Number);
-  const rightIndex = comparison2.checker.getIndexInfoOfType(right, ts30.IndexKind.Number);
+  const leftIndex = comparison2.checker.getIndexInfoOfType(left, ts33.IndexKind.Number);
+  const rightIndex = comparison2.checker.getIndexInfoOfType(right, ts33.IndexKind.Number);
   if (leftIndex?.isReadonly !== rightIndex?.isReadonly) return false;
   const leftArguments = comparison2.checker.getTypeArguments(left);
   const rightArguments = comparison2.checker.getTypeArguments(right);
@@ -29789,10 +30348,10 @@ function equivalentContainers(comparison2, left, right) {
   });
 }
 function hasClassDeclaration(type) {
-  return type.getSymbol()?.getDeclarations()?.some(ts30.isClassDeclaration) === true || type.isIntersection() && type.types.some(hasClassDeclaration);
+  return type.getSymbol()?.getDeclarations()?.some(ts33.isClassDeclaration) === true || type.isIntersection() && type.types.some(hasClassDeclaration);
 }
 function objectLike(type) {
-  return (type.flags & ts30.TypeFlags.Object) !== 0 || type.isIntersection();
+  return (type.flags & ts33.TypeFlags.Object) !== 0 || type.isIntersection();
 }
 function equivalentProperties(comparison2, left, right) {
   const { checker } = comparison2;
@@ -29807,12 +30366,12 @@ function equivalentProperties(comparison2, left, right) {
   return true;
 }
 function opaqueObject(checker, type) {
-  return checker.getIndexInfosOfType(type).length > 0 || checker.getSignaturesOfType(type, ts30.SignatureKind.Call).length > 0 || checker.getSignaturesOfType(type, ts30.SignatureKind.Construct).length > 0;
+  return checker.getIndexInfosOfType(type).length > 0 || checker.getSignaturesOfType(type, ts33.SignatureKind.Call).length > 0 || checker.getSignaturesOfType(type, ts33.SignatureKind.Construct).length > 0;
 }
 function equivalentProperty(comparison2, left, right, property, other) {
   const { checker } = comparison2;
   if (opaqueProperty(property) || opaqueProperty(other)) return false;
-  if ((property.flags & ts30.SymbolFlags.Optional) !== (other.flags & ts30.SymbolFlags.Optional)) return false;
+  if ((property.flags & ts33.SymbolFlags.Optional) !== (other.flags & ts33.SymbolFlags.Optional)) return false;
   if (isPropertyReadonlyInType(left, property.getEscapedName(), checker) !== isPropertyReadonlyInType(right, other.getEscapedName(), checker)) return false;
   const declaration = property.valueDeclaration ?? property.getDeclarations()?.[0];
   const otherDeclaration = other.valueDeclaration ?? other.getDeclarations()?.[0];
@@ -29823,39 +30382,39 @@ function equivalentProperty(comparison2, left, right, property, other) {
   );
 }
 function opaqueProperty(property) {
-  return property.getDeclarations()?.some((declaration) => ts30.isGetAccessorDeclaration(declaration) || ts30.isSetAccessorDeclaration(declaration) || ts30.isMethodDeclaration(declaration) || ts30.isMethodSignature(declaration)) === true;
+  return property.getDeclarations()?.some((declaration) => ts33.isGetAccessorDeclaration(declaration) || ts33.isSetAccessorDeclaration(declaration) || ts33.isMethodDeclaration(declaration) || ts33.isMethodSignature(declaration)) === true;
 }
 
 // src/rules/_has-authoritative-output-contract.ts
-import ts31 from "typescript";
+import ts34 from "typescript";
 function hasAuthoritativeOutputContract(checker, output, contract) {
   const callable = enclosingCallable(output);
   if (callable === void 0) return false;
   const authority = { checker, contract };
-  if (ts31.isMethodDeclaration(callable) || ts31.isGetAccessorDeclaration(callable)) return memberContract2(authority, callable);
+  if (ts34.isMethodDeclaration(callable) || ts34.isGetAccessorDeclaration(callable)) return memberContract2(authority, callable);
   const binding3 = callable.parent;
-  if ((ts31.isVariableDeclaration(binding3) || ts31.isPropertyDeclaration(binding3)) && binding3.initializer === callable && binding3.type !== void 0 && callableContract(authority, checker.getTypeFromTypeNode(binding3.type))) return true;
-  if (ts31.isPropertyDeclaration(binding3) && binding3.initializer === callable && memberContract2(authority, binding3)) return true;
+  if ((ts34.isVariableDeclaration(binding3) || ts34.isPropertyDeclaration(binding3)) && binding3.initializer === callable && binding3.type !== void 0 && callableContract(authority, checker.getTypeFromTypeNode(binding3.type))) return true;
+  if (ts34.isPropertyDeclaration(binding3) && binding3.initializer === callable && memberContract2(authority, binding3)) return true;
   const contextual = checker.getContextualType(callable);
   return contextual !== void 0 && callableContract(authority, contextual, callable);
 }
 function enclosingCallable(output) {
   for (let current = output; current !== void 0; current = current.parent) {
-    if (ts31.isMethodDeclaration(current) || ts31.isGetAccessorDeclaration(current) || ts31.isArrowFunction(current) || ts31.isFunctionExpression(current)) return current;
-    if (ts31.isFunctionDeclaration(current) || ts31.isConstructorDeclaration(current) || ts31.isSetAccessorDeclaration(current)) return void 0;
+    if (ts34.isMethodDeclaration(current) || ts34.isGetAccessorDeclaration(current) || ts34.isArrowFunction(current) || ts34.isFunctionExpression(current)) return current;
+    if (ts34.isFunctionDeclaration(current) || ts34.isConstructorDeclaration(current) || ts34.isSetAccessorDeclaration(current)) return void 0;
   }
   return void 0;
 }
 function memberContract2(authority, member3) {
-  if ((ts31.getCombinedModifierFlags(member3) & (ts31.ModifierFlags.Private | ts31.ModifierFlags.Static)) !== 0 || ts31.isPrivateIdentifier(member3.name)) return false;
+  if ((ts34.getCombinedModifierFlags(member3) & (ts34.ModifierFlags.Private | ts34.ModifierFlags.Static)) !== 0 || ts34.isPrivateIdentifier(member3.name)) return false;
   const owner = member3.parent;
   const name = authority.checker.getSymbolAtLocation(member3.name)?.getName();
   if (name === void 0) return false;
-  if (ts31.isObjectLiteralExpression(owner)) {
+  if (ts34.isObjectLiteralExpression(owner)) {
     const contextual = authority.checker.getContextualType(owner);
     return contextual !== void 0 && propertyContract(authority, contextual, name, member3, member3);
   }
-  if (!ts31.isClassDeclaration(owner) && !ts31.isClassExpression(owner)) return false;
+  if (!ts34.isClassDeclaration(owner) && !ts34.isClassExpression(owner)) return false;
   for (const clause of owner.heritageClauses ?? []) {
     for (const heritage of clause.types) {
       if (propertyContract(authority, authority.checker.getTypeAtLocation(heritage), name, member3)) return true;
@@ -29867,9 +30426,9 @@ function propertyContract(authority, type, name, member3, contextual) {
   const property = authority.checker.getPropertyOfType(type, name);
   if (property === void 0) return false;
   const declared = authority.checker.getTypeOfSymbolAtLocation(property, member3);
-  if (!ts31.isGetAccessorDeclaration(member3)) return callableContract(authority, declared, contextual);
+  if (!ts34.isGetAccessorDeclaration(member3)) return callableContract(authority, declared, contextual);
   return property.getDeclarations()?.some((declaration) => {
-    if (!(ts31.isPropertySignature(declaration) || ts31.isPropertyDeclaration(declaration) || ts31.isGetAccessorDeclaration(declaration)) || declaration.type === void 0 || declaration === member3) return false;
+    if (!(ts34.isPropertySignature(declaration) || ts34.isPropertyDeclaration(declaration) || ts34.isGetAccessorDeclaration(declaration)) || declaration.type === void 0 || declaration === member3) return false;
     return returnsContract(authority, contextual === void 0 ? declared : authority.checker.getTypeAtLocation(declaration.type));
   }) === true;
 }
@@ -30208,12 +30767,12 @@ function handWrittenObjectDeclaration(symbol) {
   const [declaration] = declarations;
   if (declarations.length !== 1 || declaration === void 0) return null;
   const plainMembers = (members) => members.length > 0 && members.every(
-    (member3) => ts32.isPropertySignature(member3) && member3.type !== void 0 && member3.modifiers?.some((modifier) => modifier.kind === ts32.SyntaxKind.ReadonlyKeyword) !== true
+    (member3) => ts35.isPropertySignature(member3) && member3.type !== void 0 && member3.modifiers?.some((modifier) => modifier.kind === ts35.SyntaxKind.ReadonlyKeyword) !== true
   );
-  if (ts32.isInterfaceDeclaration(declaration) && declaration.typeParameters === void 0 && declaration.heritageClauses === void 0 && plainMembers(declaration.members)) {
+  if (ts35.isInterfaceDeclaration(declaration) && declaration.typeParameters === void 0 && declaration.heritageClauses === void 0 && plainMembers(declaration.members)) {
     return declaration;
   }
-  if (ts32.isTypeAliasDeclaration(declaration) && declaration.typeParameters === void 0 && ts32.isTypeLiteralNode(declaration.type) && plainMembers(declaration.type.members)) {
+  if (ts35.isTypeAliasDeclaration(declaration) && declaration.typeParameters === void 0 && ts35.isTypeLiteralNode(declaration.type) && plainMembers(declaration.type.members)) {
     return declaration;
   }
   return null;
@@ -30296,7 +30855,7 @@ import {
   ESLintUtils as ESLintUtils26,
   AST_NODE_TYPES as AST_NODE_TYPES145
 } from "@typescript-eslint/utils";
-import ts33 from "typescript";
+import ts36 from "typescript";
 
 // src/rules/_empty-assertion-fix.ts
 import {
@@ -30476,7 +31035,7 @@ function isExhaustiveFiniteSwitch(node, services) {
   const constituents = discriminantType.isUnion() ? discriminantType.types : [discriminantType];
   if (!discriminantType.isUnion() || constituents.length < 2) return false;
   if (constituents.every(
-    (constituent) => (constituent.flags & ts33.TypeFlags.BooleanLiteral) !== 0
+    (constituent) => (constituent.flags & ts36.TypeFlags.BooleanLiteral) !== 0
   )) {
     return false;
   }
@@ -30498,7 +31057,7 @@ function isExhaustiveFiniteSwitch(node, services) {
   return [...expected].every((key) => handled.has(key));
 }
 function finiteTypeKey(type, checker) {
-  const finiteFlags = ts33.TypeFlags.StringLiteral | ts33.TypeFlags.NumberLiteral | ts33.TypeFlags.BooleanLiteral | ts33.TypeFlags.EnumLiteral | ts33.TypeFlags.UniqueESSymbol | ts33.TypeFlags.Null | ts33.TypeFlags.Undefined;
+  const finiteFlags = ts36.TypeFlags.StringLiteral | ts36.TypeFlags.NumberLiteral | ts36.TypeFlags.BooleanLiteral | ts36.TypeFlags.EnumLiteral | ts36.TypeFlags.UniqueESSymbol | ts36.TypeFlags.Null | ts36.TypeFlags.Undefined;
   return (type.flags & finiteFlags) !== 0 ? checker.typeToString(type) : null;
 }
 var require_assert_never_default = createRule({